RTEMS 4.11Annotated Report
Thu Dec 20 17:12:54 2012
4000b480 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
4000b480: 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();
4000b484: 40 00 02 6e call 4000be3c <geteuid>
4000b488: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000b48c: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000b490: 91 2a 20 10 sll %o0, 0x10, %o0
4000b494: 91 32 20 10 srl %o0, 0x10, %o0
4000b498: 80 a0 40 08 cmp %g1, %o0
4000b49c: 02 80 00 04 be 4000b4ac <IMFS_chown+0x2c>
4000b4a0: 80 a2 20 00 cmp %o0, 0
4000b4a4: 12 80 00 0b bne 4000b4d0 <IMFS_chown+0x50> <== ALWAYS TAKEN
4000b4a8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
4000b4ac: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
4000b4b0: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
4000b4b4: 90 07 bf f8 add %fp, -8, %o0
4000b4b8: 7f ff df 06 call 400030d0 <gettimeofday>
4000b4bc: 92 10 20 00 clr %o1
4000b4c0: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000b4c4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000b4c8: 81 c7 e0 08 ret
4000b4cc: 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 );
4000b4d0: 40 00 10 9c call 4000f740 <__errno>
4000b4d4: b0 10 3f ff mov -1, %i0
4000b4d8: 82 10 20 01 mov 1, %g1
4000b4dc: c2 22 00 00 st %g1, [ %o0 ]
4000b4e0: 81 c7 e0 08 ret
4000b4e4: 81 e8 00 00 restore
400051f0 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
400051f0: 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;
400051f4: f4 06 20 50 ld [ %i0 + 0x50 ], %i2
400051f8: 39 10 00 97 sethi %hi(0x40025c00), %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 ));
400051fc: 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 );
40005200: 80 a6 80 18 cmp %i2, %i0
40005204: 02 80 00 30 be 400052c4 <IMFS_dump_directory+0xd4>
40005208: b8 17 20 b8 or %i4, 0xb8, %i4
4000520c: 37 10 00 8f sethi %hi(0x40023c00), %i3
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
40005210: 29 10 00 8f sethi %hi(0x40023c00), %l4
return;
}
puts("");
40005214: 21 10 00 8f sethi %hi(0x40023c00), %l0
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
40005218: 27 10 00 8f sethi %hi(0x40023c00), %l3
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
4000521c: 25 10 00 8f sethi %hi(0x40023c00), %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
40005220: b6 16 e1 e0 or %i3, 0x1e0, %i3
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
40005224: a8 15 22 50 or %l4, 0x250, %l4
return;
}
puts("");
40005228: a0 14 20 d0 or %l0, 0xd0, %l0
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
4000522c: a6 14 e2 38 or %l3, 0x238, %l3
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
40005230: a4 14 a2 20 or %l2, 0x220, %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 );
40005234: 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++ )
40005238: 80 a6 60 00 cmp %i1, 0
4000523c: 06 80 00 0c bl 4000526c <IMFS_dump_directory+0x7c> <== NEVER TAKEN
40005240: ba 10 20 00 clr %i5
fprintf(stdout, "...." );
40005244: c2 07 00 00 ld [ %i4 ], %g1
40005248: 90 10 00 1b mov %i3, %o0
4000524c: d6 00 60 08 ld [ %g1 + 8 ], %o3
40005250: 92 10 20 01 mov 1, %o1
40005254: 40 00 3e 0c call 40014a84 <fwrite>
40005258: 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++ )
4000525c: ba 07 60 01 inc %i5
40005260: 80 a6 40 1d cmp %i1, %i5
40005264: 36 bf ff f9 bge,a 40005248 <IMFS_dump_directory+0x58>
40005268: c2 07 00 00 ld [ %i4 ], %g1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4000526c: c2 07 00 00 ld [ %i4 ], %g1
40005270: 90 06 a0 0c add %i2, 0xc, %o0
40005274: 40 00 3a e6 call 40013e0c <fputs>
40005278: 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;
4000527c: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
40005280: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
40005284: 80 a2 a0 06 cmp %o2, 6
40005288: 28 80 00 11 bleu,a 400052cc <IMFS_dump_directory+0xdc> <== ALWAYS TAKEN
4000528c: 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 ) );
40005290: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
40005294: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40005298: 40 00 3a 8d call 40013ccc <fprintf> <== NOT EXECUTED
4000529c: 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;
400052a0: 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 ) )
400052a4: c2 00 40 00 ld [ %g1 ], %g1
400052a8: 80 a0 60 00 cmp %g1, 0
400052ac: 22 80 00 19 be,a 40005310 <IMFS_dump_directory+0x120>
400052b0: 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 ) {
400052b4: 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 );
400052b8: 80 a6 80 18 cmp %i2, %i0
400052bc: 12 bf ff e0 bne 4000523c <IMFS_dump_directory+0x4c>
400052c0: 80 a6 60 00 cmp %i1, 0
400052c4: 81 c7 e0 08 ret
400052c8: 81 e8 00 00 restore
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
400052cc: 03 10 00 14 sethi %hi(0x40005000), %g1
400052d0: 82 10 61 d4 or %g1, 0x1d4, %g1 ! 400051d4 <bsp_interrupt_handler_default+0x18>
400052d4: c2 00 40 0a ld [ %g1 + %o2 ], %g1
400052d8: 81 c0 40 00 jmp %g1
400052dc: 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" );
400052e0: c2 07 00 00 ld [ %i4 ], %g1
400052e4: 90 10 00 12 mov %l2, %o0
400052e8: d6 00 60 08 ld [ %g1 + 8 ], %o3
400052ec: 92 10 20 01 mov 1, %o1
400052f0: 40 00 3d e5 call 40014a84 <fwrite>
400052f4: 94 10 20 13 mov 0x13, %o2
400052f8: 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 ) )
400052fc: c2 00 40 00 ld [ %g1 ], %g1
40005300: 80 a0 60 00 cmp %g1, 0
40005304: 32 bf ff ed bne,a 400052b8 <IMFS_dump_directory+0xc8> <== ALWAYS TAKEN
40005308: f4 06 80 00 ld [ %i2 ], %i2
IMFS_dump_directory( the_jnode, level + 1 );
4000530c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40005310: 7f ff ff b8 call 400051f0 <IMFS_dump_directory>
40005314: 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 ) {
40005318: 10 bf ff e8 b 400052b8 <IMFS_dump_directory+0xc8>
4000531c: 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)",
40005320: c2 07 00 00 ld [ %i4 ], %g1
40005324: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
40005328: d0 00 60 08 ld [ %g1 + 8 ], %o0
4000532c: d6 06 a0 58 ld [ %i2 + 0x58 ], %o3
40005330: 13 10 00 8f sethi %hi(0x40023c00), %o1
40005334: 40 00 3a 66 call 40013ccc <fprintf>
40005338: 92 12 62 00 or %o1, 0x200, %o1 ! 40023e00 <__FUNCTION__.6193+0x278>
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
return;
}
puts("");
4000533c: 40 00 41 d3 call 40015a88 <puts>
40005340: 90 10 00 10 mov %l0, %o0
40005344: 10 bf ff d8 b 400052a4 <IMFS_dump_directory+0xb4>
40005348: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
4000534c: c2 07 00 00 ld [ %i4 ], %g1
40005350: d4 06 a0 50 ld [ %i2 + 0x50 ], %o2
40005354: d0 00 60 08 ld [ %g1 + 8 ], %o0
40005358: d6 06 a0 54 ld [ %i2 + 0x54 ], %o3
4000535c: 13 10 00 8f sethi %hi(0x40023c00), %o1
40005360: 40 00 3a 5b call 40013ccc <fprintf>
40005364: 92 12 61 e8 or %o1, 0x1e8, %o1 ! 40023de8 <__FUNCTION__.6193+0x260>
40005368: 30 bf ff f5 b,a 4000533c <IMFS_dump_directory+0x14c>
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
4000536c: c2 07 00 00 ld [ %i4 ], %g1
40005370: 90 10 20 2f mov 0x2f, %o0
40005374: 40 00 3a 72 call 40013d3c <fputc>
40005378: d2 00 60 08 ld [ %g1 + 8 ], %o1
4000537c: 30 bf ff f0 b,a 4000533c <IMFS_dump_directory+0x14c>
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
40005380: c2 07 00 00 ld [ %i4 ], %g1
40005384: 90 10 00 13 mov %l3, %o0
40005388: d6 00 60 08 ld [ %g1 + 8 ], %o3
4000538c: 92 10 20 01 mov 1, %o1
40005390: 40 00 3d bd call 40014a84 <fwrite>
40005394: 94 10 20 12 mov 0x12, %o2
40005398: 10 bf ff c3 b 400052a4 <IMFS_dump_directory+0xb4>
4000539c: 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 ")",
400053a0: c2 07 00 00 ld [ %i4 ], %g1
400053a4: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
400053a8: d0 00 60 08 ld [ %g1 + 8 ], %o0
400053ac: 13 10 00 8f sethi %hi(0x40023c00), %o1
400053b0: 40 00 3a 47 call 40013ccc <fprintf>
400053b4: 92 12 62 10 or %o1, 0x210, %o1 ! 40023e10 <__FUNCTION__.6193+0x288>
400053b8: 30 bf ff e1 b,a 4000533c <IMFS_dump_directory+0x14c>
4000b62c <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
4000b62c: 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;
4000b630: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
4000b634: 90 10 00 18 mov %i0, %o0
4000b638: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
4000b63c: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
4000b640: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
4000b644: 40 00 03 24 call 4000c2d4 <rtems_filesystem_eval_path_check_access>
4000b648: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
4000b64c: 80 8a 20 ff btst 0xff, %o0
4000b650: 12 80 00 04 bne 4000b660 <IMFS_eval_token+0x34>
4000b654: 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)) {
4000b658: 81 c7 e0 08 ret
4000b65c: 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] == '.';
4000b660: 02 80 00 58 be 4000b7c0 <IMFS_eval_token+0x194>
4000b664: 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] == '.';
4000b668: 22 80 00 37 be,a 4000b744 <IMFS_eval_token+0x118>
4000b66c: c2 4e 80 00 ldsb [ %i2 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000b670: 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 );
4000b674: b2 07 20 54 add %i4, 0x54, %i1
while ( current != tail ) {
4000b678: 80 a7 40 19 cmp %i5, %i1
4000b67c: 02 80 00 30 be 4000b73c <IMFS_eval_token+0x110>
4000b680: 90 07 60 0c add %i5, 0xc, %o0
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
4000b684: 92 10 00 1a mov %i2, %o1
4000b688: 40 00 15 c5 call 40010d9c <strncmp>
4000b68c: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
4000b690: 80 a2 20 00 cmp %o0, 0
4000b694: 12 80 00 26 bne 4000b72c <IMFS_eval_token+0x100>
4000b698: 82 07 40 1b add %i5, %i3, %g1
4000b69c: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
4000b6a0: 80 a0 60 00 cmp %g1, 0
4000b6a4: 32 80 00 23 bne,a 4000b730 <IMFS_eval_token+0x104>
4000b6a8: 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;
4000b6ac: 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 );
4000b6b0: c4 06 20 04 ld [ %i0 + 4 ], %g2
4000b6b4: c2 00 40 00 ld [ %g1 ], %g1
4000b6b8: 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;
4000b6bc: c0 26 20 0c clr [ %i0 + 0xc ]
4000b6c0: 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;
4000b6c4: 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)) {
4000b6c8: 80 a0 60 02 cmp %g1, 2
4000b6cc: 02 80 00 43 be 4000b7d8 <IMFS_eval_token+0x1ac>
4000b6d0: 86 10 00 02 mov %g2, %g3
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
4000b6d4: 80 a0 60 03 cmp %g1, 3
4000b6d8: 02 80 00 28 be 4000b778 <IMFS_eval_token+0x14c>
4000b6dc: 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 ) {
4000b6e0: 32 80 00 2c bne,a 4000b790 <IMFS_eval_token+0x164>
4000b6e4: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
if ( node->info.directory.mt_fs != NULL ) {
4000b6e8: f6 07 60 5c ld [ %i5 + 0x5c ], %i3
4000b6ec: 80 a6 e0 00 cmp %i3, 0
4000b6f0: 02 80 00 27 be 4000b78c <IMFS_eval_token+0x160>
4000b6f4: 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(
4000b6f8: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
4000b6fc: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
4000b700: d8 17 60 3e lduh [ %i5 + 0x3e ], %o4
4000b704: 40 00 02 f4 call 4000c2d4 <rtems_filesystem_eval_path_check_access>
4000b708: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
4000b70c: 80 8a 20 ff btst 0xff, %o0
4000b710: 02 bf ff d2 be 4000b658 <IMFS_eval_token+0x2c> <== NEVER TAKEN
4000b714: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
4000b718: 92 06 e0 24 add %i3, 0x24, %o1
4000b71c: 7f ff e3 2b call 400043c8 <rtems_filesystem_eval_path_restart>
4000b720: b0 10 20 01 mov 1, %i0
4000b724: 81 c7 e0 08 ret
4000b728: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000b72c: 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 ) {
4000b730: 80 a6 40 1d cmp %i1, %i5
4000b734: 12 bf ff d4 bne 4000b684 <IMFS_eval_token+0x58>
4000b738: 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;
4000b73c: 81 c7 e0 08 ret
4000b740: 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] == '.';
4000b744: 80 a0 60 2e cmp %g1, 0x2e
4000b748: 32 bf ff cb bne,a 4000b674 <IMFS_eval_token+0x48>
4000b74c: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
4000b750: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
4000b754: 80 a0 60 2e cmp %g1, 0x2e
4000b758: 32 bf ff c7 bne,a 4000b674 <IMFS_eval_token+0x48> <== NEVER TAKEN
4000b75c: 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;
4000b760: 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 ) {
4000b764: 80 a7 60 00 cmp %i5, 0
4000b768: 02 bf ff f5 be 4000b73c <IMFS_eval_token+0x110>
4000b76c: 01 00 00 00 nop
4000b770: 10 bf ff d0 b 4000b6b0 <IMFS_eval_token+0x84>
4000b774: 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)) {
4000b778: 80 a0 a0 00 cmp %g2, 0
4000b77c: 02 80 00 20 be 4000b7fc <IMFS_eval_token+0x1d0>
4000b780: 80 89 20 10 btst 0x10, %g4
4000b784: 32 80 00 1f bne,a 4000b800 <IMFS_eval_token+0x1d4>
4000b788: 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;
4000b78c: 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;
4000b790: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000b794: 84 00 bf ff add %g2, -1, %g2
4000b798: c4 37 20 34 sth %g2, [ %i4 + 0x34 ]
++entry->reference_count;
4000b79c: c4 17 60 34 lduh [ %i5 + 0x34 ], %g2
4000b7a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000b7a4: 84 00 a0 01 inc %g2
4000b7a8: c4 37 60 34 sth %g2, [ %i5 + 0x34 ]
currentloc->node_access = entry;
4000b7ac: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
4000b7b0: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000b7b4: b0 08 e0 ff and %g3, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
4000b7b8: 81 c7 e0 08 ret
4000b7bc: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
4000b7c0: c2 4e 80 00 ldsb [ %i2 ], %g1
4000b7c4: 80 a0 60 2e cmp %g1, 0x2e
4000b7c8: 32 bf ff ab bne,a 4000b674 <IMFS_eval_token+0x48>
4000b7cc: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
4000b7d0: 10 bf ff b7 b 4000b6ac <IMFS_eval_token+0x80>
4000b7d4: 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)) {
4000b7d8: 80 a0 a0 00 cmp %g2, 0
4000b7dc: 12 80 00 04 bne 4000b7ec <IMFS_eval_token+0x1c0>
4000b7e0: 80 89 20 08 btst 8, %g4
entry = entry->info.hard_link.link_node;
4000b7e4: 10 bf ff ea b 4000b78c <IMFS_eval_token+0x160>
4000b7e8: 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)) {
4000b7ec: 22 bf ff e9 be,a 4000b790 <IMFS_eval_token+0x164>
4000b7f0: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
4000b7f4: 10 bf ff e6 b 4000b78c <IMFS_eval_token+0x160>
4000b7f8: 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;
4000b7fc: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
4000b800: 40 00 15 35 call 40010cd4 <strlen>
4000b804: 90 10 00 1d mov %i5, %o0
4000b808: 92 10 00 1d mov %i5, %o1
4000b80c: 94 10 00 08 mov %o0, %o2
4000b810: 7f ff e3 07 call 4000442c <rtems_filesystem_eval_path_recursive>
4000b814: 90 10 00 18 mov %i0, %o0
4000b818: 30 bf ff 90 b,a 4000b658 <IMFS_eval_token+0x2c>
4000b834 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4000b834: 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();
4000b838: 40 00 01 81 call 4000be3c <geteuid>
4000b83c: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000b840: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000b844: 91 2a 20 10 sll %o0, 0x10, %o0
4000b848: 91 32 20 10 srl %o0, 0x10, %o0
4000b84c: 80 a0 40 08 cmp %g1, %o0
4000b850: 02 80 00 04 be 4000b860 <IMFS_fchmod+0x2c>
4000b854: 80 a2 20 00 cmp %o0, 0
4000b858: 12 80 00 0e bne 4000b890 <IMFS_fchmod+0x5c> <== ALWAYS TAKEN
4000b85c: 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);
4000b860: 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 );
4000b864: 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);
4000b868: 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 );
4000b86c: 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);
4000b870: b2 0e 6f ff and %i1, 0xfff, %i1
4000b874: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
4000b878: 7f ff de 16 call 400030d0 <gettimeofday>
4000b87c: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
4000b880: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000b884: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000b888: 81 c7 e0 08 ret
4000b88c: 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 );
4000b890: 40 00 0f ac call 4000f740 <__errno>
4000b894: b0 10 3f ff mov -1, %i0
4000b898: 82 10 20 01 mov 1, %g1
4000b89c: c2 22 00 00 st %g1, [ %o0 ]
4000b8a0: 81 c7 e0 08 ret
4000b8a4: 81 e8 00 00 restore
4000327c <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000327c: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
40003280: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
40003284: 96 10 00 18 mov %i0, %o3
40003288: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
4000328c: 92 10 00 19 mov %i1, %o1
40003290: 40 00 2b b6 call 4000e168 <pipe_write>
40003294: 94 10 00 1a mov %i2, %o2
if (err > 0) {
40003298: b0 92 20 00 orcc %o0, 0, %i0
4000329c: 04 80 00 09 ble 400032c0 <IMFS_fifo_write+0x44>
400032a0: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
400032a4: 40 00 03 c5 call 400041b8 <gettimeofday>
400032a8: 92 10 20 00 clr %o1
400032ac: c2 07 bf f8 ld [ %fp + -8 ], %g1
400032b0: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
400032b4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
400032b8: 81 c7 e0 08 ret
400032bc: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
400032c0: 80 a6 20 00 cmp %i0, 0
400032c4: 12 80 00 04 bne 400032d4 <IMFS_fifo_write+0x58> <== ALWAYS TAKEN
400032c8: 01 00 00 00 nop
}
400032cc: 81 c7 e0 08 ret <== NOT EXECUTED
400032d0: 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);
400032d4: 40 00 38 81 call 400114d8 <__errno>
400032d8: 01 00 00 00 nop
400032dc: 82 20 00 18 neg %i0, %g1
400032e0: c2 22 00 00 st %g1, [ %o0 ]
}
400032e4: 81 c7 e0 08 ret
400032e8: 91 e8 3f ff restore %g0, -1, %o0
4000b8a8 <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
)
{
4000b8a8: 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;
4000b8ac: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
4000b8b0: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000b8b4: f2 00 80 00 ld [ %g2 ], %i1
4000b8b8: f4 00 a0 04 ld [ %g2 + 4 ], %i2
4000b8bc: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
4000b8c0: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
4000b8c4: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
4000b8c8: c2 00 e0 4c ld [ %g3 + 0x4c ], %g1
4000b8cc: f2 27 bf e8 st %i1, [ %fp + -24 ]
4000b8d0: f4 27 bf ec st %i2, [ %fp + -20 ]
4000b8d4: c6 27 bf f0 st %g3, [ %fp + -16 ]
4000b8d8: f6 27 bf f4 st %i3, [ %fp + -12 ]
4000b8dc: f8 27 bf f8 st %i4, [ %fp + -8 ]
4000b8e0: 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;
4000b8e4: c0 20 a0 08 clr [ %g2 + 8 ]
4000b8e8: 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;
4000b8ec: ba 10 00 03 mov %g3, %i5
4000b8f0: c2 00 60 04 ld [ %g1 + 4 ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
4000b8f4: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
4000b8f8: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b8fc: 80 a0 a0 00 cmp %g2, 0
4000b900: 12 80 00 13 bne 4000b94c <IMFS_fsunmount+0xa4> <== NEVER TAKEN
4000b904: c2 27 bf f8 st %g1, [ %fp + -8 ]
4000b908: 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 );
4000b90c: 84 07 60 54 add %i5, 0x54, %g2
4000b910: 80 a0 40 02 cmp %g1, %g2
4000b914: 02 80 00 0f be 4000b950 <IMFS_fsunmount+0xa8>
4000b918: 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;
4000b91c: 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);
4000b920: 80 a7 60 00 cmp %i5, 0
4000b924: 02 80 00 21 be 4000b9a8 <IMFS_fsunmount+0x100> <== NEVER TAKEN
4000b928: 01 00 00 00 nop
4000b92c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
4000b930: f8 07 60 08 ld [ %i5 + 8 ], %i4
4000b934: c4 00 40 00 ld [ %g1 ], %g2
4000b938: c2 00 60 04 ld [ %g1 + 4 ], %g1
loc.node_access = (void *)jnode;
4000b93c: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b940: 80 a0 a0 00 cmp %g2, 0
4000b944: 02 bf ff f1 be 4000b908 <IMFS_fsunmount+0x60>
4000b948: c2 27 bf f8 st %g1, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
4000b94c: 90 10 20 00 clr %o0
4000b950: 7f ff dc 53 call 40002a9c <IMFS_rmnod>
4000b954: 92 07 bf e8 add %fp, -24, %o1
if ( result != 0 )
4000b958: 80 a2 20 00 cmp %o0, 0
4000b95c: 12 80 00 15 bne 4000b9b0 <IMFS_fsunmount+0x108> <== NEVER TAKEN
4000b960: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
IMFS_node_destroy( jnode );
4000b964: 7f ff db 6c call 40002714 <IMFS_node_destroy>
4000b968: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
4000b96c: 80 a7 20 00 cmp %i4, 0
4000b970: 02 80 00 0e be 4000b9a8 <IMFS_fsunmount+0x100>
4000b974: 01 00 00 00 nop
4000b978: c2 07 20 4c ld [ %i4 + 0x4c ], %g1
4000b97c: c4 00 40 00 ld [ %g1 ], %g2
if ( IMFS_is_directory( jnode ) ) {
4000b980: 80 a0 a0 00 cmp %g2, 0
4000b984: 12 bf ff db bne 4000b8f0 <IMFS_fsunmount+0x48> <== NEVER TAKEN
4000b988: ba 10 00 1c mov %i4, %i5
4000b98c: 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 );
4000b990: 86 07 20 54 add %i4, 0x54, %g3
if ( jnode_has_children( jnode ) )
4000b994: 80 a7 40 03 cmp %i5, %g3
4000b998: 12 bf ff e3 bne 4000b924 <IMFS_fsunmount+0x7c>
4000b99c: 80 a7 60 00 cmp %i5, 0
4000b9a0: 10 bf ff d4 b 4000b8f0 <IMFS_fsunmount+0x48>
4000b9a4: ba 10 00 1c mov %i4, %i5
4000b9a8: 81 c7 e0 08 ret
4000b9ac: 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 );
4000b9b0: 7f ff f0 5c call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000b9b4: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40002600 <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]
)
{
40002600: 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 ) );
40002604: 90 10 20 01 mov 1, %o0
40002608: 40 00 01 d9 call 40002d6c <calloc>
4000260c: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
40002610: ba 92 20 00 orcc %o0, 0, %i5
40002614: 02 80 00 34 be 400026e4 <IMFS_initialize_support+0xe4>
40002618: 03 10 00 7a sethi %hi(0x4001e800), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
4000261c: c4 00 62 a4 ld [ %g1 + 0x2a4 ], %g2 ! 4001eaa4 <imfs_instance.6621>
memcpy(
40002620: 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++;
40002624: 86 00 a0 01 add %g2, 1, %g3
memcpy(
40002628: 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++;
4000262c: c4 27 40 00 st %g2, [ %i5 ]
40002630: c6 20 62 a4 st %g3, [ %g1 + 0x2a4 ]
memcpy(
40002634: 40 00 36 94 call 40010084 <memcpy>
40002638: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
4000263c: d2 07 60 08 ld [ %i5 + 8 ], %o1
40002640: 90 10 00 1d mov %i5, %o0
40002644: 96 10 20 00 clr %o3
40002648: 15 10 00 71 sethi %hi(0x4001c400), %o2
4000264c: 9a 10 20 00 clr %o5
40002650: 94 12 a3 f0 or %o2, 0x3f0, %o2
40002654: 19 00 00 10 sethi %hi(0x4000), %o4
40002658: 40 00 23 a4 call 4000b4e8 <IMFS_allocate_node>
4000265c: 98 13 21 ed or %o4, 0x1ed, %o4 ! 41ed <PROM_START+0x41ed>
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
40002660: 80 a2 20 00 cmp %o0, 0
40002664: 02 80 00 20 be 400026e4 <IMFS_initialize_support+0xe4> <== NEVER TAKEN
40002668: 09 10 00 74 sethi %hi(0x4001d000), %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;
4000266c: 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;
40002670: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40002674: c6 00 a0 04 ld [ %g2 + 4 ], %g3
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
40002678: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->ops = op_table;
4000267c: f2 26 20 0c st %i1, [ %i0 + 0xc ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
40002680: 05 10 00 78 sethi %hi(0x4001e000), %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;
40002684: 88 11 21 bc or %g4, 0x1bc, %g4
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
40002688: c4 00 a3 a0 ld [ %g2 + 0x3a0 ], %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;
4000268c: c8 26 20 2c st %g4, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
40002690: 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) {
40002694: 80 a0 a0 10 cmp %g2, 0x10
40002698: 02 80 00 0f be 400026d4 <IMFS_initialize_support+0xd4>
4000269c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
400026a0: 80 a0 a0 0f cmp %g2, 0xf
400026a4: 04 80 00 0b ble 400026d0 <IMFS_initialize_support+0xd0>
400026a8: 82 10 20 20 mov 0x20, %g1
400026ac: 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) {
400026b0: 80 a0 80 01 cmp %g2, %g1
400026b4: 22 80 00 09 be,a 400026d8 <IMFS_initialize_support+0xd8>
400026b8: 03 10 00 7a sethi %hi(0x4001e800), %g1
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
400026bc: 26 80 00 06 bl,a 400026d4 <IMFS_initialize_support+0xd4> <== NEVER TAKEN
400026c0: 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) {
400026c4: 86 80 ff ff addcc %g3, -1, %g3
400026c8: 12 bf ff fa bne 400026b0 <IMFS_initialize_support+0xb0> <== ALWAYS TAKEN
400026cc: 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);
400026d0: 84 10 20 80 mov 0x80, %g2
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
400026d4: 03 10 00 7a sethi %hi(0x4001e800), %g1
400026d8: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ] ! 4001eaa0 <imfs_memfile_bytes_per_block>
const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT]
)
{
static int imfs_instance;
int rv = 0;
400026dc: 81 c7 e0 08 ret
400026e0: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
400026e4: 40 00 34 17 call 4000f740 <__errno>
400026e8: b0 10 3f ff mov -1, %i0
400026ec: 82 10 20 0c mov 0xc, %g1
400026f0: c2 22 00 00 st %g1, [ %o0 ]
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
400026f4: 81 c7 e0 08 ret
400026f8: 81 e8 00 00 restore
400042fc <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
400042fc: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40004300: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40004304: c2 00 62 08 ld [ %g1 + 0x208 ], %g1 ! 4001ae08 <rtems_current_user_env>
switch (mode & S_IFMT) {
40004308: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000430c: c2 00 60 08 ld [ %g1 + 8 ], %g1
40004310: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
40004314: 03 00 00 3c sethi %hi(0xf000), %g1
40004318: 82 0e 40 01 and %i1, %g1, %g1
4000431c: 80 a0 40 02 cmp %g1, %g2
40004320: 22 80 00 0c be,a 40004350 <IMFS_make_generic_node+0x54>
40004324: c2 06 80 00 ld [ %i2 ], %g1
40004328: 08 80 00 1d bleu 4000439c <IMFS_make_generic_node+0xa0> <== NEVER TAKEN
4000432c: 05 00 00 04 sethi %hi(0x1000), %g2
40004330: 05 00 00 18 sethi %hi(0x6000), %g2
40004334: 80 a0 40 02 cmp %g1, %g2
40004338: 02 80 00 05 be 4000434c <IMFS_make_generic_node+0x50>
4000433c: 05 00 00 20 sethi %hi(0x8000), %g2
40004340: 80 a0 40 02 cmp %g1, %g2
40004344: 12 80 00 19 bne 400043a8 <IMFS_make_generic_node+0xac> <== ALWAYS TAKEN
40004348: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
4000434c: c2 06 80 00 ld [ %i2 ], %g1
40004350: 80 a0 60 07 cmp %g1, 7
40004354: 12 80 00 15 bne 400043a8 <IMFS_make_generic_node+0xac>
40004358: 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 =
4000435c: 94 10 20 78 mov 0x78, %o2
40004360: 40 00 07 ac call 40006210 <rtems_filesystem_eval_path_start>
40004364: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
40004368: 7f ff ff d2 call 400042b0 <IMFS_is_imfs_instance>
4000436c: ba 10 00 08 mov %o0, %i5
40004370: 80 8a 20 ff btst 0xff, %o0
40004374: 12 80 00 13 bne 400043c0 <IMFS_make_generic_node+0xc4>
40004378: d4 1f bf d0 ldd [ %fp + -48 ], %o2
IMFS_update_mtime( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
4000437c: 90 07 bf c8 add %fp, -56, %o0
40004380: 92 10 20 86 mov 0x86, %o1
40004384: 40 00 06 e7 call 40005f20 <rtems_filesystem_eval_path_error>
40004388: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000438c: 40 00 07 e1 call 40006310 <rtems_filesystem_eval_path_cleanup>
40004390: 90 07 bf c8 add %fp, -56, %o0
40004394: 81 c7 e0 08 ret
40004398: 81 e8 00 00 restore
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
4000439c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400043a0: 22 bf ff ec be,a 40004350 <IMFS_make_generic_node+0x54> <== NOT EXECUTED
400043a4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
} else {
errno = EINVAL;
400043a8: 40 00 40 36 call 40014480 <__errno>
400043ac: b0 10 3f ff mov -1, %i0
400043b0: 82 10 20 16 mov 0x16, %g1
400043b4: c2 22 00 00 st %g1, [ %o0 ]
400043b8: 81 c7 e0 08 ret
400043bc: 81 e8 00 00 restore
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
400043c0: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
400043c4: 90 10 00 1d mov %i5, %o0
400043c8: 92 10 00 1a mov %i2, %o1
400043cc: 98 10 00 19 mov %i1, %o4
400043d0: 9a 07 bf b0 add %fp, -80, %o5
400043d4: 40 00 2f 26 call 4001006c <IMFS_create_node_with_control>
400043d8: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
400043dc: 80 a2 20 00 cmp %o0, 0
400043e0: 02 bf ff eb be 4000438c <IMFS_make_generic_node+0x90>
400043e4: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
400043e8: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
400043ec: 40 00 02 0f call 40004c28 <gettimeofday>
400043f0: 90 07 bf a8 add %fp, -88, %o0
400043f4: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
400043f8: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
400043fc: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
40004400: 40 00 02 0a call 40004c28 <gettimeofday>
40004404: 92 10 20 00 clr %o1
40004408: c2 07 bf a8 ld [ %fp + -88 ], %g1
4000440c: b0 10 20 00 clr %i0
40004410: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40004414: 40 00 07 bf call 40006310 <rtems_filesystem_eval_path_cleanup>
40004418: 90 07 bf c8 add %fp, -56, %o0
4000441c: 81 c7 e0 08 ret
40004420: 81 e8 00 00 restore
4000e110 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000e110: 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 );
4000e114: 94 10 20 01 mov 1, %o2
4000e118: 90 10 00 18 mov %i0, %o0
4000e11c: 7f ff fe c9 call 4000dc40 <IMFS_memfile_get_block_pointer>
4000e120: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
4000e124: 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 );
4000e128: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
4000e12c: 80 a0 60 00 cmp %g1, 0
4000e130: 12 80 00 08 bne 4000e150 <IMFS_memfile_addblock+0x40>
4000e134: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
4000e138: 7f ff fe b5 call 4000dc0c <memfile_alloc_block>
4000e13c: 01 00 00 00 nop
if ( !memory )
4000e140: 80 a2 20 00 cmp %o0, 0
4000e144: 02 80 00 05 be 4000e158 <IMFS_memfile_addblock+0x48> <== NEVER TAKEN
4000e148: 01 00 00 00 nop
return 1;
*block_entry_ptr = memory;
4000e14c: d0 27 40 00 st %o0, [ %i5 ]
return 0;
4000e150: 81 c7 e0 08 ret
4000e154: 81 e8 00 00 restore
}
4000e158: 81 c7 e0 08 ret <== NOT EXECUTED
4000e15c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
4000e384 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
4000e384: 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 )
4000e388: 25 10 00 7a sethi %hi(0x4001e800), %l2
4000e38c: fa 04 a2 a0 ld [ %l2 + 0x2a0 ], %i5 ! 4001eaa0 <imfs_memfile_bytes_per_block>
4000e390: b9 37 60 02 srl %i5, 2, %i4
4000e394: 92 10 00 1c mov %i4, %o1
4000e398: 40 00 28 fd call 4001878c <.umul>
4000e39c: 90 07 20 01 add %i4, 1, %o0
4000e3a0: 92 10 00 1c mov %i4, %o1
4000e3a4: 40 00 28 fa call 4001878c <.umul>
4000e3a8: 90 02 20 01 inc %o0
4000e3ac: 92 10 00 1d mov %i5, %o1
4000e3b0: 40 00 28 f7 call 4001878c <.umul>
4000e3b4: 90 02 3f ff add %o0, -1, %o0
4000e3b8: 82 10 20 00 clr %g1
4000e3bc: 80 a0 40 1a cmp %g1, %i2
4000e3c0: 04 80 00 58 ble 4000e520 <IMFS_memfile_extend+0x19c> <== ALWAYS TAKEN
4000e3c4: 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 )
4000e3c8: e2 07 20 50 ld [ %i4 + 0x50 ], %l1 <== NOT EXECUTED
4000e3cc: 80 a6 80 11 cmp %i2, %l1
4000e3d0: 04 80 00 3f ble 4000e4cc <IMFS_memfile_extend+0x148> <== ALWAYS TAKEN
4000e3d4: 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;
4000e3d8: a7 3f 60 1f sra %i5, 0x1f, %l3 <== NOT EXECUTED
4000e3dc: 96 10 00 1d mov %i5, %o3
4000e3e0: 94 10 00 13 mov %l3, %o2
4000e3e4: 90 10 00 1a mov %i2, %o0
4000e3e8: 40 00 2a 7b call 40018dd4 <__divdi3>
4000e3ec: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e3f0: 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;
4000e3f4: b0 10 00 09 mov %o1, %i0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e3f8: 90 10 00 11 mov %l1, %o0
4000e3fc: 92 10 00 10 mov %l0, %o1
4000e400: 40 00 2a 75 call 40018dd4 <__divdi3>
4000e404: 94 10 00 13 mov %l3, %o2
4000e408: a2 10 00 09 mov %o1, %l1
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e40c: 90 10 00 09 mov %o1, %o0
4000e410: 40 00 28 df call 4001878c <.umul>
4000e414: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000e418: ba 10 00 11 mov %l1, %i5
4000e41c: 80 a6 00 11 cmp %i0, %l1
4000e420: 1a 80 00 07 bcc 4000e43c <IMFS_memfile_extend+0xb8> <== ALWAYS TAKEN
4000e424: 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);
4000e428: 10 80 00 1d b 4000e49c <IMFS_memfile_extend+0x118> <== NOT EXECUTED
4000e42c: 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++ ) {
4000e430: 80 a6 00 1d cmp %i0, %i5
4000e434: 0a 80 00 1a bcs 4000e49c <IMFS_memfile_extend+0x118>
4000e438: 92 10 20 00 clr %o1
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
4000e43c: 92 10 00 1d mov %i5, %o1
4000e440: 7f ff ff 34 call 4000e110 <IMFS_memfile_addblock>
4000e444: 90 10 00 1c mov %i4, %o0
4000e448: 80 a2 20 00 cmp %o0, 0
4000e44c: 12 80 00 26 bne 4000e4e4 <IMFS_memfile_extend+0x160> <== NEVER TAKEN
4000e450: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
4000e454: 22 bf ff f7 be,a 4000e430 <IMFS_memfile_extend+0xac>
4000e458: ba 07 60 01 inc %i5
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
block_p *block_ptr =
4000e45c: 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;
4000e460: e6 04 a2 a0 ld [ %l2 + 0x2a0 ], %l3
block_p *block_ptr =
4000e464: 94 10 20 00 clr %o2
4000e468: 7f ff fd f6 call 4000dc40 <IMFS_memfile_get_block_pointer>
4000e46c: 90 10 00 1c mov %i4, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
4000e470: 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;
4000e474: 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);
4000e478: 90 02 00 10 add %o0, %l0, %o0
4000e47c: 92 10 20 00 clr %o1
4000e480: 40 00 07 3e call 40010178 <memset>
4000e484: 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++ ) {
4000e488: ba 07 60 01 inc %i5
4000e48c: 80 a6 00 1d cmp %i0, %i5
4000e490: 1a bf ff eb bcc 4000e43c <IMFS_memfile_extend+0xb8>
4000e494: 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);
4000e498: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
4000e49c: f4 3f 20 50 std %i2, [ %i4 + 0x50 ]
IMFS_update_ctime(the_jnode);
4000e4a0: 7f ff d3 0c call 400030d0 <gettimeofday>
4000e4a4: 90 07 bf f8 add %fp, -8, %o0
4000e4a8: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
4000e4ac: 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);
4000e4b0: c2 27 20 48 st %g1, [ %i4 + 0x48 ]
IMFS_update_mtime(the_jnode);
4000e4b4: 7f ff d3 07 call 400030d0 <gettimeofday>
4000e4b8: 92 10 20 00 clr %o1
4000e4bc: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000e4c0: c2 27 20 44 st %g1, [ %i4 + 0x44 ]
return 0;
4000e4c4: 81 c7 e0 08 ret
4000e4c8: 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 )
4000e4cc: 12 80 00 04 bne 4000e4dc <IMFS_memfile_extend+0x158> <== NEVER TAKEN
4000e4d0: 80 a6 c0 10 cmp %i3, %l0
4000e4d4: 18 bf ff c2 bgu 4000e3dc <IMFS_memfile_extend+0x58> <== ALWAYS TAKEN
4000e4d8: 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;
}
4000e4dc: 81 c7 e0 08 ret <== NOT EXECUTED
4000e4e0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
4000e4e4: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED
4000e4e8: 0a 80 00 08 bcs 4000e508 <IMFS_memfile_extend+0x184> <== NOT EXECUTED
4000e4ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
4000e4f0: 7f ff ff 99 call 4000e354 <IMFS_memfile_remove_block> <== NOT EXECUTED
4000e4f4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
4000e4f8: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
4000e4fc: 80 a4 40 1d cmp %l1, %i5 <== NOT EXECUTED
4000e500: 08 bf ff fc bleu 4000e4f0 <IMFS_memfile_extend+0x16c> <== NOT EXECUTED
4000e504: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
4000e508: 40 00 04 8e call 4000f740 <__errno> <== NOT EXECUTED
4000e50c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e510: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
4000e514: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e518: 81 c7 e0 08 ret <== NOT EXECUTED
4000e51c: 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 )
4000e520: 12 80 00 04 bne 4000e530 <IMFS_memfile_extend+0x1ac> <== NEVER TAKEN
4000e524: 80 a2 00 1b cmp %o0, %i3
4000e528: 38 bf ff a9 bgu,a 4000e3cc <IMFS_memfile_extend+0x48>
4000e52c: e2 07 20 50 ld [ %i4 + 0x50 ], %l1
rtems_set_errno_and_return_minus_one( EFBIG );
4000e530: 40 00 04 84 call 4000f740 <__errno>
4000e534: b0 10 3f ff mov -1, %i0
4000e538: 82 10 20 1b mov 0x1b, %g1
4000e53c: c2 22 00 00 st %g1, [ %o0 ]
4000e540: 81 c7 e0 08 ret
4000e544: 81 e8 00 00 restore
4000dc40 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4000dc40: 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 ) {
4000dc44: 03 10 00 7a sethi %hi(0x4001e800), %g1
4000dc48: fa 00 62 a0 ld [ %g1 + 0x2a0 ], %i5 ! 4001eaa0 <imfs_memfile_bytes_per_block>
4000dc4c: bb 37 60 02 srl %i5, 2, %i5
4000dc50: 82 07 7f ff add %i5, -1, %g1
4000dc54: 80 a6 40 01 cmp %i1, %g1
4000dc58: 38 80 00 0b bgu,a 4000dc84 <IMFS_memfile_get_block_pointer+0x44>
4000dc5c: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
4000dc60: 80 a6 a0 00 cmp %i2, 0
4000dc64: 12 80 00 4e bne 4000dd9c <IMFS_memfile_get_block_pointer+0x15c>
4000dc68: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
4000dc6c: 80 a2 20 00 cmp %o0, 0
4000dc70: 02 80 00 6d be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000dc74: 01 00 00 00 nop
return 0;
return &info->indirect[ my_block ];
4000dc78: b3 2e 60 02 sll %i1, 2, %i1
4000dc7c: 81 c7 e0 08 ret
4000dc80: 91 ea 00 19 restore %o0, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4000dc84: 40 00 2a c2 call 4001878c <.umul>
4000dc88: 92 10 00 1d mov %i5, %o1
4000dc8c: 82 02 3f ff add %o0, -1, %g1
4000dc90: 80 a6 40 01 cmp %i1, %g1
4000dc94: 08 80 00 2b bleu 4000dd40 <IMFS_memfile_get_block_pointer+0x100>
4000dc98: b8 10 00 08 mov %o0, %i4
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4000dc9c: 90 02 20 01 inc %o0
4000dca0: 40 00 2a bb call 4001878c <.umul>
4000dca4: 92 10 00 1d mov %i5, %o1
4000dca8: 90 02 3f ff add %o0, -1, %o0
4000dcac: 80 a6 40 08 cmp %i1, %o0
4000dcb0: 18 80 00 5d bgu 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000dcb4: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000dcb8: 92 10 00 1d mov %i5, %o1
4000dcbc: 40 00 2b 9a call 40018b24 <.urem>
4000dcc0: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000dcc4: 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;
4000dcc8: a0 10 00 08 mov %o0, %l0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000dccc: 40 00 2a ea call 40018874 <.udiv>
4000dcd0: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4000dcd4: 92 10 00 1d mov %i5, %o1
4000dcd8: 40 00 2a e7 call 40018874 <.udiv>
4000dcdc: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000dce0: 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;
4000dce4: b6 10 00 08 mov %o0, %i3
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000dce8: 40 00 2b 8f call 40018b24 <.urem>
4000dcec: 90 10 00 1c mov %i4, %o0
p = info->triply_indirect;
if ( malloc_it ) {
4000dcf0: 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;
4000dcf4: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
4000dcf8: 02 80 00 3d be 4000ddec <IMFS_memfile_get_block_pointer+0x1ac>
4000dcfc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
4000dd00: 80 a2 20 00 cmp %o0, 0
4000dd04: 02 80 00 66 be 4000de9c <IMFS_memfile_get_block_pointer+0x25c>
4000dd08: 01 00 00 00 nop
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
4000dd0c: b7 2e e0 02 sll %i3, 2, %i3
4000dd10: c4 02 00 1b ld [ %o0 + %i3 ], %g2
if ( !p1 ) {
4000dd14: 80 a0 a0 00 cmp %g2, 0
4000dd18: 02 80 00 5a be 4000de80 <IMFS_memfile_get_block_pointer+0x240>
4000dd1c: b6 02 00 1b add %o0, %i3, %i3
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
4000dd20: bb 2f 60 02 sll %i5, 2, %i5
4000dd24: d0 00 80 1d ld [ %g2 + %i5 ], %o0
if ( !p2 ) {
4000dd28: 80 a2 20 00 cmp %o0, 0
4000dd2c: 02 80 00 47 be 4000de48 <IMFS_memfile_get_block_pointer+0x208>
4000dd30: 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 ];
4000dd34: b1 2c 20 02 sll %l0, 2, %i0
4000dd38: 81 c7 e0 08 ret
4000dd3c: 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;
4000dd40: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000dd44: 92 10 00 1d mov %i5, %o1
4000dd48: 40 00 2b 77 call 40018b24 <.urem>
4000dd4c: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000dd50: 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;
4000dd54: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000dd58: 40 00 2a c7 call 40018874 <.udiv>
4000dd5c: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
4000dd60: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( malloc_it ) {
4000dd64: 80 a6 a0 00 cmp %i2, 0
4000dd68: 02 80 00 17 be 4000ddc4 <IMFS_memfile_get_block_pointer+0x184>
4000dd6c: ba 10 00 08 mov %o0, %i5
if ( !p ) {
4000dd70: 80 a0 60 00 cmp %g1, 0
4000dd74: 02 80 00 3c be 4000de64 <IMFS_memfile_get_block_pointer+0x224>
4000dd78: 01 00 00 00 nop
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
4000dd7c: bb 2f 60 02 sll %i5, 2, %i5
4000dd80: d0 00 40 1d ld [ %g1 + %i5 ], %o0
if ( !p1 ) {
4000dd84: 80 a2 20 00 cmp %o0, 0
4000dd88: 02 80 00 29 be 4000de2c <IMFS_memfile_get_block_pointer+0x1ec>
4000dd8c: ba 00 40 1d add %g1, %i5, %i5
if ( !p1 )
return 0;
p[ doubly ] = (block_p) p1;
}
return (block_p *)&p1[ singly ];
4000dd90: b1 2f 20 02 sll %i4, 2, %i0
4000dd94: 81 c7 e0 08 ret
4000dd98: 91 ea 00 18 restore %o0, %i0, %o0
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
4000dd9c: 80 a2 20 00 cmp %o0, 0
4000dda0: 32 bf ff b7 bne,a 4000dc7c <IMFS_memfile_get_block_pointer+0x3c>
4000dda4: b3 2e 60 02 sll %i1, 2, %i1
p = memfile_alloc_block();
4000dda8: 7f ff ff 99 call 4000dc0c <memfile_alloc_block>
4000ddac: 01 00 00 00 nop
if ( !p )
4000ddb0: 80 a2 20 00 cmp %o0, 0
4000ddb4: 02 80 00 1c be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ddb8: 01 00 00 00 nop
return 0;
info->indirect = p;
4000ddbc: 10 bf ff af b 4000dc78 <IMFS_memfile_get_block_pointer+0x38>
4000ddc0: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4000ddc4: 80 a0 60 00 cmp %g1, 0
4000ddc8: 02 80 00 17 be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ddcc: bb 2a 20 02 sll %o0, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
4000ddd0: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p )
4000ddd4: 80 a0 60 00 cmp %g1, 0
4000ddd8: 02 80 00 13 be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000dddc: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
4000dde0: b1 2f 20 02 sll %i4, 2, %i0
4000dde4: 81 c7 e0 08 ret
4000dde8: 91 e8 40 18 restore %g1, %i0, %o0
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
4000ddec: 80 a2 20 00 cmp %o0, 0
4000ddf0: 02 80 00 0d be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ddf4: b7 2e e0 02 sll %i3, 2, %i3
return 0;
p1 = (block_p *) p[ triply ];
4000ddf8: c2 02 00 1b ld [ %o0 + %i3 ], %g1
if ( !p1 )
4000ddfc: 80 a0 60 00 cmp %g1, 0
4000de00: 02 80 00 09 be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de04: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
4000de08: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
4000de0c: 80 a0 60 00 cmp %g1, 0
4000de10: 02 80 00 05 be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de14: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
4000de18: b1 2c 20 02 sll %l0, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
4000de1c: 81 c7 e0 08 ret
4000de20: 91 e8 40 18 restore %g1, %i0, %o0
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
return 0;
4000de24: 81 c7 e0 08 ret <== NOT EXECUTED
4000de28: 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();
4000de2c: 7f ff ff 78 call 4000dc0c <memfile_alloc_block>
4000de30: 01 00 00 00 nop
if ( !p1 )
4000de34: 80 a2 20 00 cmp %o0, 0
4000de38: 02 bf ff fb be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de3c: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
4000de40: 10 bf ff d4 b 4000dd90 <IMFS_memfile_get_block_pointer+0x150>
4000de44: d0 27 40 00 st %o0, [ %i5 ]
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
4000de48: 7f ff ff 71 call 4000dc0c <memfile_alloc_block>
4000de4c: 01 00 00 00 nop
if ( !p2 )
4000de50: 80 a2 20 00 cmp %o0, 0
4000de54: 02 bf ff f4 be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de58: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
4000de5c: 10 bf ff b6 b 4000dd34 <IMFS_memfile_get_block_pointer+0xf4>
4000de60: d0 27 40 00 st %o0, [ %i5 ]
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
4000de64: 7f ff ff 6a call 4000dc0c <memfile_alloc_block>
4000de68: 01 00 00 00 nop
if ( !p )
4000de6c: 82 92 20 00 orcc %o0, 0, %g1
4000de70: 02 bf ff ed be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de74: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
4000de78: 10 bf ff c1 b 4000dd7c <IMFS_memfile_get_block_pointer+0x13c>
4000de7c: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
4000de80: 7f ff ff 63 call 4000dc0c <memfile_alloc_block>
4000de84: 01 00 00 00 nop
if ( !p1 )
4000de88: 84 92 20 00 orcc %o0, 0, %g2
4000de8c: 02 bf ff e6 be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de90: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
4000de94: 10 bf ff a3 b 4000dd20 <IMFS_memfile_get_block_pointer+0xe0>
4000de98: c4 26 c0 00 st %g2, [ %i3 ]
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
4000de9c: 7f ff ff 5c call 4000dc0c <memfile_alloc_block>
4000dea0: 01 00 00 00 nop
if ( !p )
4000dea4: 80 a2 20 00 cmp %o0, 0
4000dea8: 02 bf ff df be 4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000deac: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
4000deb0: 10 bf ff 97 b 4000dd0c <IMFS_memfile_get_block_pointer+0xcc>
4000deb4: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
4000deb8 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000deb8: 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;
4000debc: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
4000dec0: 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 ) {
4000dec4: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000dec8: a0 10 00 19 mov %i1, %l0
4000decc: 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 ) {
4000ded0: 80 a0 60 05 cmp %g1, 5
4000ded4: 02 80 00 68 be 4000e074 <IMFS_memfile_read+0x1bc>
4000ded8: 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 )
4000dedc: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
4000dee0: 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;
4000dee4: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
4000dee8: c8 06 20 54 ld [ %i0 + 0x54 ], %g4
4000deec: 80 a0 c0 02 cmp %g3, %g2
4000def0: 04 80 00 42 ble 4000dff8 <IMFS_memfile_read+0x140> <== ALWAYS TAKEN
4000def4: ba 07 00 1a add %i4, %i2, %i5
my_length = the_jnode->info.file.size - start;
4000def8: 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;
4000defc: 33 10 00 7a sethi %hi(0x4001e800), %i1 <== NOT EXECUTED
4000df00: fa 06 62 a0 ld [ %i1 + 0x2a0 ], %i5 ! 4001eaa0 <imfs_memfile_bytes_per_block>
4000df04: 90 10 00 10 mov %l0, %o0
4000df08: b7 3f 60 1f sra %i5, 0x1f, %i3
4000df0c: 96 10 00 1d mov %i5, %o3
4000df10: 94 10 00 1b mov %i3, %o2
4000df14: 40 00 2c 9b call 40019180 <__moddi3>
4000df18: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000df1c: 90 10 00 10 mov %l0, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000df20: a8 10 00 09 mov %o1, %l4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000df24: 94 10 00 1b mov %i3, %o2
4000df28: 92 10 00 11 mov %l1, %o1
4000df2c: 40 00 2b aa call 40018dd4 <__divdi3>
4000df30: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
4000df34: 80 a5 20 00 cmp %l4, 0
4000df38: 02 80 00 37 be 4000e014 <IMFS_memfile_read+0x15c>
4000df3c: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000df40: ba 27 40 14 sub %i5, %l4, %i5
4000df44: 80 a7 00 1d cmp %i4, %i5
4000df48: 18 80 00 59 bgu 4000e0ac <IMFS_memfile_read+0x1f4>
4000df4c: 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 );
4000df50: 90 10 00 12 mov %l2, %o0
4000df54: 92 10 00 1a mov %i2, %o1
4000df58: 94 10 20 00 clr %o2
4000df5c: 7f ff ff 39 call 4000dc40 <IMFS_memfile_get_block_pointer>
4000df60: b0 10 20 00 clr %i0
if ( !block_ptr )
4000df64: 80 a2 20 00 cmp %o0, 0
4000df68: 02 80 00 22 be 4000dff0 <IMFS_memfile_read+0x138> <== NEVER TAKEN
4000df6c: 94 10 00 10 mov %l0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4000df70: d2 02 00 00 ld [ %o0 ], %o1
4000df74: 90 10 00 13 mov %l3, %o0
4000df78: 40 00 08 43 call 40010084 <memcpy>
4000df7c: 92 02 40 14 add %o1, %l4, %o1
4000df80: fa 06 62 a0 ld [ %i1 + 0x2a0 ], %i5
dest += to_copy;
4000df84: b6 04 c0 10 add %l3, %l0, %i3
block++;
4000df88: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000df8c: b8 27 00 10 sub %i4, %l0, %i4
copied += to_copy;
4000df90: 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 ) {
4000df94: 80 a7 00 1d cmp %i4, %i5
4000df98: 1a 80 00 0e bcc 4000dfd0 <IMFS_memfile_read+0x118>
4000df9c: 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 ) {
4000dfa0: 10 80 00 21 b 4000e024 <IMFS_memfile_read+0x16c>
4000dfa4: 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 );
4000dfa8: d2 00 40 00 ld [ %g1 ], %o1
4000dfac: 40 00 08 36 call 40010084 <memcpy>
4000dfb0: 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 ) {
4000dfb4: c2 06 62 a0 ld [ %i1 + 0x2a0 ], %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;
4000dfb8: b6 06 c0 1d add %i3, %i5, %i3
block++;
4000dfbc: 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 ) {
4000dfc0: 80 a0 40 1c cmp %g1, %i4
4000dfc4: 18 80 00 17 bgu 4000e020 <IMFS_memfile_read+0x168>
4000dfc8: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000dfcc: 94 10 20 00 clr %o2
4000dfd0: 92 10 00 1a mov %i2, %o1
4000dfd4: 7f ff ff 1b call 4000dc40 <IMFS_memfile_get_block_pointer>
4000dfd8: 90 10 00 12 mov %l2, %o0
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4000dfdc: 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 );
4000dfe0: 82 10 00 08 mov %o0, %g1
if ( !block_ptr )
4000dfe4: 80 a0 60 00 cmp %g1, 0
4000dfe8: 12 bf ff f0 bne 4000dfa8 <IMFS_memfile_read+0xf0> <== ALWAYS TAKEN
4000dfec: 90 10 00 1b mov %i3, %o0
}
IMFS_update_atime( the_jnode );
return copied;
}
4000dff0: 81 c7 e0 08 ret <== NOT EXECUTED
4000dff4: 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 )
4000dff8: 12 bf ff c2 bne 4000df00 <IMFS_memfile_read+0x48> <== NEVER TAKEN
4000dffc: 33 10 00 7a sethi %hi(0x4001e800), %i1
4000e000: 80 a7 40 04 cmp %i5, %g4
4000e004: 08 bf ff c0 bleu 4000df04 <IMFS_memfile_read+0x4c>
4000e008: fa 06 62 a0 ld [ %i1 + 0x2a0 ], %i5
my_length = the_jnode->info.file.size - start;
4000e00c: 10 bf ff bd b 4000df00 <IMFS_memfile_read+0x48>
4000e010: b8 21 00 01 sub %g4, %g1, %i4
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
4000e014: 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;
4000e018: 10 bf ff df b 4000df94 <IMFS_memfile_read+0xdc>
4000e01c: 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 ) {
4000e020: 80 a7 20 00 cmp %i4, 0
4000e024: 02 80 00 0e be 4000e05c <IMFS_memfile_read+0x1a4>
4000e028: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e02c: 90 10 00 12 mov %l2, %o0
4000e030: 92 10 00 1a mov %i2, %o1
4000e034: 7f ff ff 03 call 4000dc40 <IMFS_memfile_get_block_pointer>
4000e038: 94 10 20 00 clr %o2
if ( !block_ptr )
4000e03c: 80 a2 20 00 cmp %o0, 0
4000e040: 02 bf ff ec be 4000dff0 <IMFS_memfile_read+0x138> <== NEVER TAKEN
4000e044: 94 10 00 1c mov %i4, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4000e048: d2 02 00 00 ld [ %o0 ], %o1
4000e04c: 90 10 00 1b mov %i3, %o0
4000e050: 40 00 08 0d call 40010084 <memcpy>
4000e054: b0 06 00 1c add %i0, %i4, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000e058: 90 07 bf f8 add %fp, -8, %o0
4000e05c: 7f ff d4 1d call 400030d0 <gettimeofday>
4000e060: 92 10 20 00 clr %o1
4000e064: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000e068: c2 24 a0 40 st %g1, [ %l2 + 0x40 ]
return copied;
}
4000e06c: 81 c7 e0 08 ret
4000e070: 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))
4000e074: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
4000e078: 82 10 20 00 clr %g1
4000e07c: 86 a6 c0 11 subcc %i3, %l1, %g3
4000e080: 84 66 80 19 subx %i2, %i1, %g2
4000e084: 80 a0 40 02 cmp %g1, %g2
4000e088: 04 80 00 0b ble 4000e0b4 <IMFS_memfile_read+0x1fc> <== ALWAYS TAKEN
4000e08c: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
my_length = the_jnode->info.linearfile.size - start;
4000e090: b0 26 c0 11 sub %i3, %l1, %i0 <== NOT EXECUTED
memcpy(dest, &file_ptr[start], my_length);
4000e094: 92 02 40 11 add %o1, %l1, %o1
4000e098: 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 );
4000e09c: 40 00 07 fa call 40010084 <memcpy>
4000e0a0: 90 10 00 13 mov %l3, %o0
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000e0a4: 10 bf ff ee b 4000e05c <IMFS_memfile_read+0x1a4>
4000e0a8: 90 07 bf f8 add %fp, -8, %o0
4000e0ac: 10 bf ff a9 b 4000df50 <IMFS_memfile_read+0x98>
4000e0b0: 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))
4000e0b4: 12 80 00 04 bne 4000e0c4 <IMFS_memfile_read+0x20c> <== NEVER TAKEN
4000e0b8: 80 a7 00 03 cmp %i4, %g3
4000e0bc: 38 bf ff f6 bgu,a 4000e094 <IMFS_memfile_read+0x1dc> <== ALWAYS TAKEN
4000e0c0: 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;
4000e0c4: 10 bf ff f4 b 4000e094 <IMFS_memfile_read+0x1dc> <== NOT EXECUTED
4000e0c8: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4000e1dc <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4000e1dc: 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;
4000e1e0: 39 10 00 7a sethi %hi(0x4001e800), %i4
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4000e1e4: 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;
4000e1e8: f4 07 22 a0 ld [ %i4 + 0x2a0 ], %i2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4000e1ec: 80 a0 60 00 cmp %g1, 0
4000e1f0: 02 80 00 05 be 4000e204 <IMFS_memfile_remove+0x28>
4000e1f4: b5 36 a0 02 srl %i2, 2, %i2
memfile_free_blocks_in_table( &info->indirect, to_free );
4000e1f8: 90 06 20 58 add %i0, 0x58, %o0
4000e1fc: 7f ff ff e2 call 4000e184 <memfile_free_blocks_in_table>
4000e200: 92 10 00 1a mov %i2, %o1
}
if ( info->doubly_indirect ) {
4000e204: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000e208: 80 a0 60 00 cmp %g1, 0
4000e20c: 02 80 00 1b be 4000e278 <IMFS_memfile_remove+0x9c>
4000e210: c4 07 22 a0 ld [ %i4 + 0x2a0 ], %g2
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000e214: 85 30 a0 02 srl %g2, 2, %g2
4000e218: 80 a0 a0 00 cmp %g2, 0
4000e21c: 02 80 00 14 be 4000e26c <IMFS_memfile_remove+0x90> <== NEVER TAKEN
4000e220: 90 10 20 00 clr %o0
4000e224: 37 10 00 7a sethi %hi(0x4001e800), %i3
4000e228: ba 10 20 00 clr %i5
4000e22c: 10 80 00 03 b 4000e238 <IMFS_memfile_remove+0x5c>
4000e230: b6 16 e2 a0 or %i3, 0x2a0, %i3
4000e234: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( info->doubly_indirect[i] ) {
4000e238: 91 2a 20 02 sll %o0, 2, %o0
4000e23c: c4 00 40 08 ld [ %g1 + %o0 ], %g2
4000e240: 80 a0 a0 00 cmp %g2, 0
4000e244: 02 80 00 04 be 4000e254 <IMFS_memfile_remove+0x78> <== NEVER TAKEN
4000e248: 90 00 40 08 add %g1, %o0, %o0
memfile_free_blocks_in_table(
4000e24c: 7f ff ff ce call 4000e184 <memfile_free_blocks_in_table>
4000e250: 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++ ) {
4000e254: c2 06 c0 00 ld [ %i3 ], %g1
4000e258: ba 07 60 01 inc %i5
4000e25c: 83 30 60 02 srl %g1, 2, %g1
4000e260: 80 a7 40 01 cmp %i5, %g1
4000e264: 0a bf ff f4 bcs 4000e234 <IMFS_memfile_remove+0x58>
4000e268: 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 );
4000e26c: 90 06 20 5c add %i0, 0x5c, %o0
4000e270: 7f ff ff c5 call 4000e184 <memfile_free_blocks_in_table>
4000e274: 92 10 00 1a mov %i2, %o1
}
if ( info->triply_indirect ) {
4000e278: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000e27c: 80 a2 20 00 cmp %o0, 0
4000e280: 02 80 00 33 be 4000e34c <IMFS_memfile_remove+0x170>
4000e284: c4 07 22 a0 ld [ %i4 + 0x2a0 ], %g2
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000e288: 85 30 a0 02 srl %g2, 2, %g2
4000e28c: 80 a0 a0 00 cmp %g2, 0
4000e290: 22 80 00 2d be,a 4000e344 <IMFS_memfile_remove+0x168> <== NEVER TAKEN
4000e294: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
4000e298: f8 02 00 00 ld [ %o0 ], %i4
if ( !p ) /* ensure we have a valid pointer */
4000e29c: 80 a7 20 00 cmp %i4, 0
4000e2a0: 22 80 00 29 be,a 4000e344 <IMFS_memfile_remove+0x168> <== NEVER TAKEN
4000e2a4: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
4000e2a8: 37 10 00 7a sethi %hi(0x4001e800), %i3
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4000e2ac: a0 10 20 00 clr %l0
if ( !p ) /* ensure we have a valid pointer */
4000e2b0: b2 10 20 00 clr %i1
4000e2b4: b6 16 e2 a0 or %i3, 0x2a0, %i3
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
4000e2b8: 80 a0 a0 00 cmp %g2, 0
4000e2bc: 22 80 00 13 be,a 4000e308 <IMFS_memfile_remove+0x12c> <== NEVER TAKEN
4000e2c0: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
4000e2c4: 90 10 20 00 clr %o0
4000e2c8: ba 10 20 00 clr %i5
if ( p[j] ) {
4000e2cc: 91 2a 20 02 sll %o0, 2, %o0
4000e2d0: c2 07 00 08 ld [ %i4 + %o0 ], %g1
4000e2d4: 80 a0 60 00 cmp %g1, 0
4000e2d8: 02 80 00 04 be 4000e2e8 <IMFS_memfile_remove+0x10c> <== NEVER TAKEN
4000e2dc: 90 07 00 08 add %i4, %o0, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4000e2e0: 7f ff ff a9 call 4000e184 <memfile_free_blocks_in_table>
4000e2e4: 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++ ) {
4000e2e8: c2 06 c0 00 ld [ %i3 ], %g1
4000e2ec: ba 07 60 01 inc %i5
4000e2f0: 83 30 60 02 srl %g1, 2, %g1
4000e2f4: 80 a7 40 01 cmp %i5, %g1
4000e2f8: 0a bf ff f5 bcs 4000e2cc <IMFS_memfile_remove+0xf0>
4000e2fc: 90 10 00 1d mov %i5, %o0
4000e300: 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(
4000e304: 90 02 00 10 add %o0, %l0, %o0
4000e308: 7f ff ff 9f call 4000e184 <memfile_free_blocks_in_table>
4000e30c: 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++ ) {
4000e310: c4 06 c0 00 ld [ %i3 ], %g2
4000e314: b2 06 60 01 inc %i1
4000e318: 85 30 a0 02 srl %g2, 2, %g2
4000e31c: 80 a6 40 02 cmp %i1, %g2
4000e320: 1a 80 00 09 bcc 4000e344 <IMFS_memfile_remove+0x168>
4000e324: 90 06 20 60 add %i0, 0x60, %o0
p = (block_p *) info->triply_indirect[i];
4000e328: 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(
4000e32c: 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];
4000e330: f8 02 00 10 ld [ %o0 + %l0 ], %i4
if ( !p ) /* ensure we have a valid pointer */
4000e334: 80 a7 20 00 cmp %i4, 0
4000e338: 12 bf ff e1 bne 4000e2bc <IMFS_memfile_remove+0xe0> <== ALWAYS TAKEN
4000e33c: 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(
4000e340: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
4000e344: 7f ff ff 90 call 4000e184 <memfile_free_blocks_in_table>
4000e348: 92 10 00 1a mov %i2, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
4000e34c: 81 c7 e0 08 ret
4000e350: 81 e8 00 00 restore
4000e354 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000e354: 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 );
4000e358: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000e35c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e360: 7f ff fe 38 call 4000dc40 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
4000e364: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e368: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
4000e36c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
4000e370: 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 );
4000e374: 7f ff ff 7b call 4000e160 <memfile_free_block> <== NOT EXECUTED
4000e378: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
4000e37c: 81 c7 e0 08 ret <== NOT EXECUTED
4000e380: 81 e8 00 00 restore <== NOT EXECUTED
4000e548 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4000e548: 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 ) {
4000e54c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000e550: 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;
4000e554: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
4000e558: 80 a0 80 01 cmp %g2, %g1
4000e55c: 14 80 00 5e bg 4000e6d4 <IMFS_memfile_write+0x18c> <== NEVER TAKEN
4000e560: c6 06 20 54 ld [ %i0 + 0x54 ], %g3
4000e564: 80 a0 80 01 cmp %g2, %g1
4000e568: 02 80 00 59 be 4000e6cc <IMFS_memfile_write+0x184> <== ALWAYS TAKEN
4000e56c: 80 a2 c0 03 cmp %o3, %g3
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e570: 21 10 00 7a sethi %hi(0x4001e800), %l0 <== NOT EXECUTED
4000e574: fa 04 22 a0 ld [ %l0 + 0x2a0 ], %i5 ! 4001eaa0 <imfs_memfile_bytes_per_block>
4000e578: 90 10 00 19 mov %i1, %o0
4000e57c: a3 3f 60 1f sra %i5, 0x1f, %l1
4000e580: 92 10 00 1a mov %i2, %o1
4000e584: 94 10 00 11 mov %l1, %o2
4000e588: 40 00 2a fe call 40019180 <__moddi3>
4000e58c: 96 10 00 1d mov %i5, %o3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e590: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e594: a4 10 00 09 mov %o1, %l2
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e598: 94 10 00 11 mov %l1, %o2
4000e59c: 92 10 00 1a mov %i2, %o1
4000e5a0: 40 00 2a 0d call 40018dd4 <__divdi3>
4000e5a4: 96 10 00 1d mov %i5, %o3
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
4000e5a8: 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 ) {
4000e5ac: 80 a4 a0 00 cmp %l2, 0
4000e5b0: 02 80 00 16 be 4000e608 <IMFS_memfile_write+0xc0>
4000e5b4: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000e5b8: b2 27 40 12 sub %i5, %l2, %i1
4000e5bc: 80 a6 40 1c cmp %i1, %i4
4000e5c0: 38 80 00 02 bgu,a 4000e5c8 <IMFS_memfile_write+0x80>
4000e5c4: 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 );
4000e5c8: 90 10 00 18 mov %i0, %o0
4000e5cc: 92 10 00 1a mov %i2, %o1
4000e5d0: 7f ff fd 9c call 4000dc40 <IMFS_memfile_get_block_pointer>
4000e5d4: 94 10 20 00 clr %o2
if ( !block_ptr )
4000e5d8: 80 a2 20 00 cmp %o0, 0
4000e5dc: 02 80 00 22 be 4000e664 <IMFS_memfile_write+0x11c> <== NEVER TAKEN
4000e5e0: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4000e5e4: d0 02 00 00 ld [ %o0 ], %o0
4000e5e8: 92 10 00 1b mov %i3, %o1
4000e5ec: 90 02 00 12 add %o0, %l2, %o0
4000e5f0: 40 00 06 a5 call 40010084 <memcpy>
4000e5f4: 94 10 00 19 mov %i1, %o2
4000e5f8: fa 04 22 a0 ld [ %l0 + 0x2a0 ], %i5
src += to_copy;
4000e5fc: b6 06 c0 19 add %i3, %i1, %i3
block++;
4000e600: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000e604: 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 ) {
4000e608: 80 a7 00 1d cmp %i4, %i5
4000e60c: 1a 80 00 0e bcc 4000e644 <IMFS_memfile_write+0xfc>
4000e610: 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 ) {
4000e614: 10 80 00 17 b 4000e670 <IMFS_memfile_write+0x128>
4000e618: 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 );
4000e61c: d0 02 00 00 ld [ %o0 ], %o0
4000e620: 40 00 06 99 call 40010084 <memcpy>
4000e624: 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 ) {
4000e628: c2 04 22 a0 ld [ %l0 + 0x2a0 ], %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;
4000e62c: b6 06 c0 1d add %i3, %i5, %i3
block++;
4000e630: 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 ) {
4000e634: 80 a0 40 1c cmp %g1, %i4
4000e638: 18 80 00 0d bgu 4000e66c <IMFS_memfile_write+0x124>
4000e63c: b2 06 40 1d add %i1, %i5, %i1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e640: 92 10 00 1a mov %i2, %o1
4000e644: 94 10 20 00 clr %o2
4000e648: 7f ff fd 7e call 4000dc40 <IMFS_memfile_get_block_pointer>
4000e64c: 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 );
4000e650: 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 )
4000e654: 80 a2 20 00 cmp %o0, 0
4000e658: 12 bf ff f1 bne 4000e61c <IMFS_memfile_write+0xd4> <== ALWAYS TAKEN
4000e65c: 94 10 00 1d mov %i5, %o2
4000e660: 82 10 00 19 mov %i1, %g1 <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000e664: 81 c7 e0 08 ret <== NOT EXECUTED
4000e668: 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 ) {
4000e66c: 80 a7 20 00 cmp %i4, 0
4000e670: 02 80 00 0f be 4000e6ac <IMFS_memfile_write+0x164>
4000e674: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e678: 90 10 00 18 mov %i0, %o0
4000e67c: 92 10 00 1a mov %i2, %o1
4000e680: 7f ff fd 70 call 4000dc40 <IMFS_memfile_get_block_pointer>
4000e684: 94 10 20 00 clr %o2
if ( !block_ptr )
4000e688: 80 a2 20 00 cmp %o0, 0
4000e68c: 02 bf ff f6 be 4000e664 <IMFS_memfile_write+0x11c> <== NEVER TAKEN
4000e690: 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 );
4000e694: d0 02 00 00 ld [ %o0 ], %o0
4000e698: 92 10 00 1b mov %i3, %o1
4000e69c: 94 10 00 1c mov %i4, %o2
4000e6a0: 40 00 06 79 call 40010084 <memcpy>
4000e6a4: b2 06 40 1c add %i1, %i4, %i1
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4000e6a8: 90 07 bf f8 add %fp, -8, %o0
4000e6ac: 7f ff d2 89 call 400030d0 <gettimeofday>
4000e6b0: 92 10 20 00 clr %o1
4000e6b4: c4 07 bf f8 ld [ %fp + -8 ], %g2
return copied;
4000e6b8: 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 );
4000e6bc: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
4000e6c0: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
return copied;
}
4000e6c4: 81 c7 e0 08 ret
4000e6c8: 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 ) {
4000e6cc: 08 bf ff aa bleu 4000e574 <IMFS_memfile_write+0x2c>
4000e6d0: 21 10 00 7a sethi %hi(0x4001e800), %l0
bool zero_fill = start > the_jnode->info.file.size;
4000e6d4: 80 a6 40 01 cmp %i1, %g1
4000e6d8: 04 80 00 0b ble 4000e704 <IMFS_memfile_write+0x1bc> <== ALWAYS TAKEN
4000e6dc: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
4000e6e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e6e4: 92 0a 60 01 and %o1, 1, %o1
4000e6e8: 7f ff ff 27 call 4000e384 <IMFS_memfile_extend>
4000e6ec: 94 10 20 00 clr %o2
if ( status )
4000e6f0: 82 92 20 00 orcc %o0, 0, %g1
4000e6f4: 02 bf ff a0 be 4000e574 <IMFS_memfile_write+0x2c>
4000e6f8: 21 10 00 7a sethi %hi(0x4001e800), %l0
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000e6fc: 81 c7 e0 08 ret
4000e700: 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;
4000e704: 02 80 00 0b be 4000e730 <IMFS_memfile_write+0x1e8> <== ALWAYS TAKEN
4000e708: 80 a6 80 03 cmp %i2, %g3
4000e70c: 92 10 20 00 clr %o1 <== NOT EXECUTED
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
4000e710: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e714: 92 0a 60 01 and %o1, 1, %o1
4000e718: 7f ff ff 1b call 4000e384 <IMFS_memfile_extend>
4000e71c: 94 10 20 00 clr %o2
if ( status )
4000e720: 82 92 20 00 orcc %o0, 0, %g1
4000e724: 02 bf ff 94 be 4000e574 <IMFS_memfile_write+0x2c>
4000e728: 21 10 00 7a sethi %hi(0x4001e800), %l0
4000e72c: 30 bf ff f4 b,a 4000e6fc <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;
4000e730: 18 bf ff ed bgu 4000e6e4 <IMFS_memfile_write+0x19c>
4000e734: 90 10 00 18 mov %i0, %o0
4000e738: 10 bf ff f7 b 4000e714 <IMFS_memfile_write+0x1cc>
4000e73c: 92 10 20 00 clr %o1
40002804 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40002804: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
40002808: 03 00 00 3c sethi %hi(0xf000), %g1
4000280c: 05 00 00 10 sethi %hi(0x4000), %g2
40002810: 82 0e c0 01 and %i3, %g1, %g1
40002814: 80 a0 40 02 cmp %g1, %g2
40002818: 02 80 00 2b be 400028c4 <IMFS_mknod+0xc0>
4000281c: 05 00 00 20 sethi %hi(0x8000), %g2
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
40002820: 80 a0 40 02 cmp %g1, %g2
40002824: 02 80 00 2a be 400028cc <IMFS_mknod+0xc8>
40002828: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
4000282c: 05 00 00 08 sethi %hi(0x2000), %g2
40002830: 88 0e c0 04 and %i3, %g4, %g4
40002834: 80 a1 00 02 cmp %g4, %g2
40002838: 02 80 00 07 be 40002854 <IMFS_mknod+0x50>
4000283c: 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 )) {
40002840: 80 a0 40 02 cmp %g1, %g2
40002844: 22 80 00 06 be,a 4000285c <IMFS_mknod+0x58> <== ALWAYS TAKEN
40002848: 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 =
4000284c: 10 80 00 05 b 40002860 <IMFS_mknod+0x5c> <== NOT EXECUTED
40002850: 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(
40002854: 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;
40002858: 86 10 20 01 mov 1, %g3
4000285c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40002860: 82 00 e0 02 add %g3, 2, %g1
40002864: c4 00 a0 08 ld [ %g2 + 8 ], %g2
40002868: 83 28 60 02 sll %g1, 2, %g1
4000286c: d2 00 80 01 ld [ %g2 + %g1 ], %o1
40002870: 90 10 00 18 mov %i0, %o0
40002874: 94 10 00 19 mov %i1, %o2
40002878: 96 10 00 1a mov %i2, %o3
4000287c: 98 10 00 1b mov %i3, %o4
40002880: 40 00 23 4f call 4000b5bc <IMFS_create_node_with_control>
40002884: 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 ) {
40002888: 80 a2 20 00 cmp %o0, 0
4000288c: 02 80 00 12 be 400028d4 <IMFS_mknod+0xd0>
40002890: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = parentloc->node_access;
40002894: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
40002898: 40 00 02 0e call 400030d0 <gettimeofday>
4000289c: 90 07 bf e0 add %fp, -32, %o0
400028a0: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
400028a4: 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 );
400028a8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
400028ac: 40 00 02 09 call 400030d0 <gettimeofday>
400028b0: 92 10 20 00 clr %o1
400028b4: c2 07 bf e0 ld [ %fp + -32 ], %g1
400028b8: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
400028bc: 81 c7 e0 08 ret
400028c0: 91 e8 20 00 restore %g0, 0, %o0
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
400028c4: 10 bf ff e6 b 4000285c <IMFS_mknod+0x58>
400028c8: 86 10 20 00 clr %g3
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
400028cc: 10 bf ff e4 b 4000285c <IMFS_mknod+0x58>
400028d0: 86 10 20 04 mov 4, %g3
} else {
rv = -1;
}
return rv;
}
400028d4: 81 c7 e0 08 ret
400028d8: 91 e8 3f ff restore %g0, -1, %o0
400028dc <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400028dc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400028e0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400028e4: 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;
400028e8: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
400028ec: c4 00 80 00 ld [ %g2 ], %g2
400028f0: 80 a0 a0 00 cmp %g2, 0
400028f4: 12 80 00 0f bne 40002930 <IMFS_mount+0x54>
400028f8: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
400028fc: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40002900: 80 a0 a0 00 cmp %g2, 0
40002904: 12 80 00 05 bne 40002918 <IMFS_mount+0x3c> <== NEVER TAKEN
40002908: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
4000290c: 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;
40002910: 81 c7 e0 08 ret
40002914: 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;
40002918: 40 00 33 8a call 4000f740 <__errno> <== NOT EXECUTED
4000291c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002920: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
40002924: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40002928: 81 c7 e0 08 ret <== NOT EXECUTED
4000292c: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40002930: 40 00 33 84 call 4000f740 <__errno>
40002934: b0 10 3f ff mov -1, %i0
40002938: 82 10 20 14 mov 0x14, %g1
4000293c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40002940: 81 c7 e0 08 ret
40002944: 81 e8 00 00 restore
4000ba4c <IMFS_node_remove_directory>:
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
4000ba4c: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
4000ba50: 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 );
4000ba54: 82 06 20 54 add %i0, 0x54, %g1
4000ba58: 80 a0 80 01 cmp %g2, %g1
4000ba5c: 12 80 00 08 bne 4000ba7c <IMFS_node_remove_directory+0x30>
4000ba60: 01 00 00 00 nop
errno = ENOTEMPTY;
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
4000ba64: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000ba68: 80 a0 60 00 cmp %g1, 0
4000ba6c: 12 80 00 0a bne 4000ba94 <IMFS_node_remove_directory+0x48><== NEVER TAKEN
4000ba70: 01 00 00 00 nop
errno = EBUSY;
node = NULL;
}
return node;
}
4000ba74: 81 c7 e0 08 ret
4000ba78: 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;
4000ba7c: 40 00 0f 31 call 4000f740 <__errno>
4000ba80: b0 10 20 00 clr %i0
4000ba84: 82 10 20 5a mov 0x5a, %g1
4000ba88: c2 22 00 00 st %g1, [ %o0 ]
4000ba8c: 81 c7 e0 08 ret
4000ba90: 81 e8 00 00 restore
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
errno = EBUSY;
4000ba94: 40 00 0f 2b call 4000f740 <__errno> <== NOT EXECUTED
4000ba98: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000ba9c: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
4000baa0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
node = NULL;
}
return node;
}
4000baa4: 81 c7 e0 08 ret <== NOT EXECUTED
4000baa8: 81 e8 00 00 restore <== NOT EXECUTED
40002948 <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;
40002948: 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;
4000294c: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40002950: 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 ) {
40002954: 80 a0 60 02 cmp %g1, 2
40002958: 02 80 00 06 be 40002970 <IMFS_node_type+0x28>
4000295c: 80 a0 60 05 cmp %g1, 5
40002960: 02 80 00 08 be 40002980 <IMFS_node_type+0x38> <== NEVER TAKEN
40002964: 90 10 20 04 mov 4, %o0
type = imfs_type;
break;
}
return type;
}
40002968: 81 c3 e0 08 retl
4000296c: 90 10 00 01 mov %g1, %o0
40002970: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
40002974: 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;
40002978: 81 c3 e0 08 retl
4000297c: d0 00 40 00 ld [ %g1 ], %o0
40002980: 81 c3 e0 08 retl <== NOT EXECUTED
40002988 <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++ )
40002988: 80 a2 a0 00 cmp %o2, 0
4000298c: 02 80 00 16 be 400029e4 <IMFS_readlink+0x5c> <== NEVER TAKEN
40002990: c8 02 20 08 ld [ %o0 + 8 ], %g4
40002994: c2 01 20 50 ld [ %g4 + 0x50 ], %g1
40002998: c4 48 40 00 ldsb [ %g1 ], %g2
4000299c: 80 a0 a0 00 cmp %g2, 0
400029a0: 02 80 00 11 be 400029e4 <IMFS_readlink+0x5c> <== NEVER TAKEN
400029a4: c2 08 40 00 ldub [ %g1 ], %g1
400029a8: 84 10 20 00 clr %g2
400029ac: 10 80 00 07 b 400029c8 <IMFS_readlink+0x40>
400029b0: 90 10 20 00 clr %o0
400029b4: c2 01 20 50 ld [ %g4 + 0x50 ], %g1
400029b8: c6 48 40 08 ldsb [ %g1 + %o0 ], %g3
400029bc: 80 a0 e0 00 cmp %g3, 0
400029c0: 02 80 00 07 be 400029dc <IMFS_readlink+0x54>
400029c4: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = node->info.sym_link.name[i];
400029c8: 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++ )
400029cc: 90 02 20 01 inc %o0
400029d0: 80 a2 00 0a cmp %o0, %o2
400029d4: 12 bf ff f8 bne 400029b4 <IMFS_readlink+0x2c>
400029d8: 84 10 00 08 mov %o0, %g2
buf[i] = node->info.sym_link.name[i];
return i;
}
400029dc: 81 c3 e0 08 retl
400029e0: 01 00 00 00 nop
400029e4: 81 c3 e0 08 retl <== NOT EXECUTED
400029e8: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
400029ec <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400029ec: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
400029f0: 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 ) {
400029f4: c2 07 60 08 ld [ %i5 + 8 ], %g1
400029f8: 80 a0 60 00 cmp %g1, 0
400029fc: 02 80 00 22 be 40002a84 <IMFS_rename+0x98> <== NEVER TAKEN
40002a00: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
40002a04: 80 a7 20 1f cmp %i4, 0x1f
40002a08: 18 80 00 19 bgu 40002a6c <IMFS_rename+0x80> <== NEVER TAKEN
40002a0c: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
40002a10: 92 10 00 1b mov %i3, %o1
40002a14: 40 00 35 9c call 40010084 <memcpy>
40002a18: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
40002a1c: b8 07 40 1c add %i5, %i4, %i4
40002a20: c0 2f 20 0c clrb [ %i4 + 0xc ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40002a24: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40002a28: 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 );
40002a2c: 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;
40002a30: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40002a34: 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;
40002a38: 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;
40002a3c: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
40002a40: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
40002a44: fa 26 a0 58 st %i5, [ %i2 + 0x58 ]
old_last->next = the_node;
40002a48: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
40002a4c: c2 27 60 04 st %g1, [ %i5 + 4 ]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
40002a50: 90 07 bf f8 add %fp, -8, %o0
40002a54: 40 00 01 9f call 400030d0 <gettimeofday>
40002a58: 92 10 20 00 clr %o1
40002a5c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40002a60: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
40002a64: 81 c7 e0 08 ret
40002a68: 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;
40002a6c: 40 00 33 35 call 4000f740 <__errno> <== NOT EXECUTED
40002a70: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002a74: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40002a78: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40002a7c: 81 c7 e0 08 ret <== NOT EXECUTED
40002a80: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
40002a84: 40 00 33 2f call 4000f740 <__errno> <== NOT EXECUTED
40002a88: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002a8c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40002a90: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40002a94: 81 c7 e0 08 ret <== NOT EXECUTED
40002a98: 81 e8 00 00 restore <== NOT EXECUTED
40002b88 <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40002b88: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40002b8c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40002b90: 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;
40002b94: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
40002b98: c4 00 80 00 ld [ %g2 ], %g2
40002b9c: 80 a0 a0 00 cmp %g2, 0
40002ba0: 12 80 00 0f bne 40002bdc <IMFS_unmount+0x54> <== NEVER TAKEN
40002ba4: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
40002ba8: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40002bac: 80 a0 80 18 cmp %g2, %i0
40002bb0: 12 80 00 05 bne 40002bc4 <IMFS_unmount+0x3c> <== NEVER TAKEN
40002bb4: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
40002bb8: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
40002bbc: 81 c7 e0 08 ret
40002bc0: 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;
40002bc4: 40 00 32 df call 4000f740 <__errno> <== NOT EXECUTED
40002bc8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002bcc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40002bd0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40002bd4: 81 c7 e0 08 ret <== NOT EXECUTED
40002bd8: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40002bdc: 40 00 32 d9 call 4000f740 <__errno> <== NOT EXECUTED
40002be0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002be4: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
40002be8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40002bec: 81 c7 e0 08 ret <== NOT EXECUTED
40002bf0: 81 e8 00 00 restore <== NOT EXECUTED
400032d0 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
400032d0: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
400032d4: 03 10 00 71 sethi %hi(0x4001c400), %g1
400032d8: c2 08 60 49 ldub [ %g1 + 0x49 ], %g1 ! 4001c449 <Configuration+0x31>
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Control *heap = RTEMS_Malloc_Heap;
400032dc: 05 10 00 78 sethi %hi(0x4001e000), %g2
if ( !rtems_configuration_get_unified_work_area() ) {
400032e0: 80 a0 60 00 cmp %g1, 0
400032e4: 12 80 00 17 bne 40003340 <RTEMS_Malloc_Initialize+0x70>
400032e8: f6 00 a3 60 ld [ %g2 + 0x360 ], %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) {
400032ec: 80 a6 60 00 cmp %i1, 0
400032f0: 02 80 00 23 be 4000337c <RTEMS_Malloc_Initialize+0xac>
400032f4: 21 10 00 21 sethi %hi(0x40008400), %l0
400032f8: ba 10 20 00 clr %i5
400032fc: a0 14 22 98 or %l0, 0x298, %l0
40003300: b8 10 00 10 mov %l0, %i4
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
40003304: d2 06 00 00 ld [ %i0 ], %o1
40003308: d4 06 20 04 ld [ %i0 + 4 ], %o2
4000330c: 90 10 00 1b mov %i3, %o0
40003310: 9f c7 00 00 call %i4
40003314: 96 10 20 08 mov 8, %o3
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
40003318: 80 a2 20 00 cmp %o0, 0
4000331c: 32 80 00 02 bne,a 40003324 <RTEMS_Malloc_Initialize+0x54><== ALWAYS TAKEN
40003320: 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) {
40003324: ba 07 60 01 inc %i5
40003328: 80 a7 40 19 cmp %i5, %i1
4000332c: 12 bf ff f6 bne 40003304 <RTEMS_Malloc_Initialize+0x34> <== NEVER TAKEN
40003330: b0 06 20 08 add %i0, 8, %i0
if ( space_available > 0 ) {
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40003334: 80 a7 00 10 cmp %i4, %l0
40003338: 02 80 00 12 be 40003380 <RTEMS_Malloc_Initialize+0xb0> <== NEVER TAKEN
4000333c: 90 10 20 00 clr %o0
}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
40003340: 03 10 00 7a sethi %hi(0x4001e800), %g1
40003344: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 4001ea90 <rtems_malloc_statistics_helpers>
40003348: 80 a0 60 00 cmp %g1, 0
4000334c: 02 80 00 05 be 40003360 <RTEMS_Malloc_Initialize+0x90>
40003350: 3b 10 00 7b sethi %hi(0x4001ec00), %i5
(*rtems_malloc_statistics_helpers->initialize)();
40003354: c2 00 40 00 ld [ %g1 ], %g1
40003358: 9f c0 40 00 call %g1
4000335c: 01 00 00 00 nop
}
MSBUMP( space_available, _Protected_heap_Get_size( heap ) );
40003360: f8 07 61 40 ld [ %i5 + 0x140 ], %i4
40003364: 40 00 17 db call 400092d0 <_Protected_heap_Get_size>
40003368: 90 10 00 1b mov %i3, %o0
4000336c: 90 02 00 1c add %o0, %i4, %o0
40003370: d0 27 61 40 st %o0, [ %i5 + 0x140 ]
40003374: 81 c7 e0 08 ret
40003378: 81 e8 00 00 restore
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
_Internal_error_Occurred(
4000337c: 90 10 20 00 clr %o0
40003380: 92 10 20 01 mov 1, %o1
40003384: 40 00 15 62 call 4000890c <_Internal_error_Occurred>
40003388: 94 10 20 17 mov 0x17, %o2
40024f5c <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
40024f5c: 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) {
40024f60: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED
40024f64: 02 80 00 56 be 400250bc <Stack_check_Dump_threads_usage+0x160><== NOT EXECUTED
40024f68: 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 );
40024f6c: e2 06 21 38 ld [ %i0 + 0x138 ], %l1 <== NOT EXECUTED
40024f70: f8 06 20 b8 ld [ %i0 + 0xb8 ], %i4 <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
40024f74: 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;
40024f78: 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);
40024f7c: 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++)
40024f80: 86 0e bf fc and %i2, -4, %g3 <== NOT EXECUTED
40024f84: 86 00 40 03 add %g1, %g3, %g3 <== NOT EXECUTED
40024f88: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
40024f8c: 1a 80 00 10 bcc 40024fcc <Stack_check_Dump_threads_usage+0x70><== NOT EXECUTED
40024f90: 05 29 69 69 sethi %hi(0xa5a5a400), %g2 <== NOT EXECUTED
if (*base != U32_PATTERN)
40024f94: c8 07 20 20 ld [ %i4 + 0x20 ], %g4 <== NOT EXECUTED
40024f98: 84 10 a1 a5 or %g2, 0x1a5, %g2 <== NOT EXECUTED
40024f9c: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
40024fa0: 22 80 00 08 be,a 40024fc0 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
40024fa4: 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);
40024fa8: 10 80 00 37 b 40025084 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
40024fac: 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)
40024fb0: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
40024fb4: 12 80 00 34 bne 40025084 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
40024fb8: 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++)
40024fbc: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED
40024fc0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
40024fc4: 38 bf ff fb bgu,a 40024fb0 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
40024fc8: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
40024fcc: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40024fd0: 02 80 00 31 be 40025094 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
40024fd4: a0 10 20 00 clr %l0 <== NOT EXECUTED
#endif
{
(*print_handler)(
40024fd8: f2 06 20 08 ld [ %i0 + 8 ], %i1 <== NOT EXECUTED
40024fdc: 39 10 01 9f sethi %hi(0x40067c00), %i4 <== NOT EXECUTED
40024fe0: 37 10 01 9f sethi %hi(0x40067c00), %i3 <== NOT EXECUTED
40024fe4: e4 07 20 fc ld [ %i4 + 0xfc ], %l2 <== NOT EXECUTED
40024fe8: f0 06 e1 00 ld [ %i3 + 0x100 ], %i0 <== NOT EXECUTED
40024fec: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
40024ff0: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
40024ff4: 7f ff a8 86 call 4000f20c <rtems_object_get_name> <== NOT EXECUTED
40024ff8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40024ffc: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40025000: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40025004: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40025008: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4002500c: 9f c6 00 00 call %i0 <== NOT EXECUTED
40025010: 92 12 62 f0 or %o1, 0x2f0, %o1 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
40025014: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
40025018: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
4002501c: c4 06 e1 00 ld [ %i3 + 0x100 ], %g2 <== NOT EXECUTED
40025020: d0 07 20 fc ld [ %i4 + 0xfc ], %o0 <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
40025024: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
40025028: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
4002502c: 96 02 80 0b add %o2, %o3, %o3 <== NOT EXECUTED
40025030: 92 12 63 10 or %o1, 0x310, %o1 <== NOT EXECUTED
40025034: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
40025038: 9f c0 80 00 call %g2 <== NOT EXECUTED
4002503c: 9a 10 00 1a mov %i2, %o5 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
40025040: 05 10 01 9f sethi %hi(0x40067c00), %g2 <== NOT EXECUTED
40025044: c4 00 a0 f8 ld [ %g2 + 0xf8 ], %g2 ! 40067cf8 <Stack_check_Initialized><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40025048: c2 06 e1 00 ld [ %i3 + 0x100 ], %g1 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
4002504c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40025050: 12 80 00 07 bne 4002506c <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
40025054: d0 07 20 fc ld [ %i4 + 0xfc ], %o0 <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40025058: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
4002505c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40025060: 92 12 63 30 or %o1, 0x330, %o1 ! 4005eb30 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
40025064: 81 c7 e0 08 ret <== NOT EXECUTED
40025068: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
4002506c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40025070: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40025074: 9f c0 40 00 call %g1 <== NOT EXECUTED
40025078: 92 12 63 40 or %o1, 0x340, %o1 ! 4005eb40 <RTEMS_BDPART_MBR_MASTER_TYPE+0x310><== NOT EXECUTED
4002507c: 81 c7 e0 08 ret <== NOT EXECUTED
40025080: 81 e8 00 00 restore <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
40025084: 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 );
40025088: a0 04 00 1a add %l0, %i2, %l0 <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
4002508c: 12 bf ff d3 bne 40024fd8 <Stack_check_Dump_threads_usage+0x7c><== NOT EXECUTED
40025090: 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 );
40025094: 37 10 01 9f sethi %hi(0x40067c00), %i3 <== NOT EXECUTED
40025098: 39 10 01 9f sethi %hi(0x40067c00), %i4 <== NOT EXECUTED
4002509c: c2 06 e1 00 ld [ %i3 + 0x100 ], %g1 <== NOT EXECUTED
400250a0: d0 07 20 fc ld [ %i4 + 0xfc ], %o0 <== NOT EXECUTED
400250a4: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
400250a8: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
400250ac: 9f c0 40 00 call %g1 <== NOT EXECUTED
400250b0: 92 12 63 00 or %o1, 0x300, %o1 ! 4005eb00 <RTEMS_BDPART_MBR_MASTER_TYPE+0x2d0><== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400250b4: 10 bf ff d9 b 40025018 <Stack_check_Dump_threads_usage+0xbc><== NOT EXECUTED
400250b8: 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)
400250bc: 3b 10 01 a3 sethi %hi(0x40068c00), %i5 <== NOT EXECUTED
400250c0: ba 17 62 ec or %i5, 0x2ec, %i5 ! 40068eec <Stack_check_Interrupt_stack><== NOT EXECUTED
400250c4: f8 07 60 04 ld [ %i5 + 4 ], %i4 <== NOT EXECUTED
400250c8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
400250cc: 02 bf ff e6 be 40025064 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
400250d0: a2 10 20 00 clr %l1 <== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
400250d4: 10 bf ff a8 b 40024f74 <Stack_check_Dump_threads_usage+0x18><== NOT EXECUTED
400250d8: b0 10 20 00 clr %i0 <== NOT EXECUTED
400251d0 <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)
{
400251d0: 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");
400251d4: 11 10 01 7a sethi %hi(0x4005e800), %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);
400251d8: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
400251dc: 7f ff 79 ed call 40003990 <printk> <== NOT EXECUTED
400251e0: 90 12 23 48 or %o0, 0x348, %o0 <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
400251e4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400251e8: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
400251ec: 7f ff 79 e9 call 40003990 <printk> <== NOT EXECUTED
400251f0: 90 12 23 58 or %o0, 0x358, %o0 ! 4005eb58 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328><== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
400251f4: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
400251f8: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
400251fc: 7f ff 79 e5 call 40003990 <printk> <== NOT EXECUTED
40025200: 90 12 23 78 or %o0, 0x378, %o0 ! 4005eb78 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348><== NOT EXECUTED
printk(
40025204: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40025208: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
4002520c: 7f ff 79 e1 call 40003990 <printk> <== NOT EXECUTED
40025210: 90 12 23 90 or %o0, 0x390, %o0 ! 4005eb90 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360><== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
40025214: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED
40025218: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
4002521c: 7f ff a7 fc call 4000f20c <rtems_object_get_name> <== NOT EXECUTED
40025220: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
40025224: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40025228: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
4002522c: 7f ff 79 d9 call 40003990 <printk> <== NOT EXECUTED
40025230: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 4005eba8 <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)
40025234: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2 <== NOT EXECUTED
40025238: 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(
4002523c: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
40025240: 96 02 80 09 add %o2, %o1, %o3 <== NOT EXECUTED
40025244: 7f ff 79 d3 call 40003990 <printk> <== NOT EXECUTED
40025248: 90 12 23 c0 or %o0, 0x3c0, %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) {
4002524c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40025250: 02 80 00 05 be 40025264 <Stack_check_report_blown_task+0x94><== NOT EXECUTED
40025254: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
40025258: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
4002525c: 7f ff 88 b8 call 4000753c <rtems_fatal> <== NOT EXECUTED
40025260: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
40025264: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
40025268: 94 07 60 08 add %i5, 8, %o2 <== NOT EXECUTED
4002526c: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
40025270: 7f ff 79 c8 call 40003990 <printk> <== NOT EXECUTED
40025274: 96 07 60 18 add %i5, 0x18, %o3 <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
40025278: 10 bf ff f9 b 4002525c <Stack_check_report_blown_task+0x8c><== NOT EXECUTED
4002527c: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40007d78 <_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);
40007d78: c2 02 00 00 ld [ %o0 ], %g1
40007d7c: 80 a0 60 00 cmp %g1, 0
40007d80: 22 80 00 04 be,a 40007d90 <_API_extensions_Add_post_switch+0x18>
40007d84: c2 02 20 04 ld [ %o0 + 4 ], %g1
40007d88: 81 c3 e0 08 retl
40007d8c: 01 00 00 00 nop
40007d90: 80 a0 60 00 cmp %g1, 0
40007d94: 12 bf ff fd bne 40007d88 <_API_extensions_Add_post_switch+0x10><== NEVER TAKEN
40007d98: 03 10 00 7b sethi %hi(0x4001ec00), %g1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
40007d9c: 82 10 63 30 or %g1, 0x330, %g1 ! 4001ef30 <_API_extensions_Post_switch_list>
40007da0: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
40007da4: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
40007da8: 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;
40007dac: c6 22 00 00 st %g3, [ %o0 ]
tail->previous = the_node;
old_last->next = the_node;
40007db0: d0 20 80 00 st %o0, [ %g2 ]
the_node->previous = old_last;
40007db4: 81 c3 e0 08 retl
40007db8: c4 22 20 04 st %g2, [ %o0 + 4 ]
40007dbc <_API_extensions_Run_postdriver>:
}
}
#endif
void _API_extensions_Run_postdriver( void )
{
40007dbc: 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;
40007dc0: 39 10 00 7c sethi %hi(0x4001f000), %i4
40007dc4: fa 07 20 78 ld [ %i4 + 0x78 ], %i5 ! 4001f078 <_API_extensions_List>
40007dc8: b8 17 20 78 or %i4, 0x78, %i4
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
40007dcc: b8 07 20 04 add %i4, 4, %i4
40007dd0: 80 a7 40 1c cmp %i5, %i4
40007dd4: 02 80 00 09 be 40007df8 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
40007dd8: 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)();
40007ddc: c2 07 60 08 ld [ %i5 + 8 ], %g1
40007de0: 9f c0 40 00 call %g1
40007de4: 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 ) {
40007de8: 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 );
40007dec: 80 a7 40 1c cmp %i5, %i4
40007df0: 32 bf ff fc bne,a 40007de0 <_API_extensions_Run_postdriver+0x24>
40007df4: c2 07 60 08 ld [ %i5 + 8 ], %g1
40007df8: 81 c7 e0 08 ret
40007dfc: 81 e8 00 00 restore
4000a12c <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
4000a12c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
4000a130: 03 10 00 6b sethi %hi(0x4001ac00), %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 );
4000a134: 7f ff e4 c6 call 4000344c <sparc_disable_interrupts>
4000a138: fa 00 61 00 ld [ %g1 + 0x100 ], %i5 ! 4001ad00 <_Per_CPU_Information+0x10>
4000a13c: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
4000a140: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
4000a144: 80 a0 60 00 cmp %g1, 0
4000a148: 02 80 00 2b be 4000a1f4 <_CORE_RWLock_Release+0xc8>
4000a14c: 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 ) {
4000a150: 22 80 00 22 be,a 4000a1d8 <_CORE_RWLock_Release+0xac>
4000a154: 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;
4000a158: 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;
4000a15c: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
4000a160: 7f ff e4 bf call 4000345c <sparc_enable_interrupts>
4000a164: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
4000a168: 40 00 07 e0 call 4000c0e8 <_Thread_queue_Dequeue>
4000a16c: 90 10 00 18 mov %i0, %o0
if ( next ) {
4000a170: 80 a2 20 00 cmp %o0, 0
4000a174: 22 80 00 24 be,a 4000a204 <_CORE_RWLock_Release+0xd8>
4000a178: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
4000a17c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4000a180: 80 a0 60 01 cmp %g1, 1
4000a184: 02 80 00 22 be 4000a20c <_CORE_RWLock_Release+0xe0>
4000a188: 84 10 20 01 mov 1, %g2
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4000a18c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000a190: 82 00 60 01 inc %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4000a194: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4000a198: 10 80 00 09 b 4000a1bc <_CORE_RWLock_Release+0x90>
4000a19c: 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 ||
4000a1a0: 80 a0 60 01 cmp %g1, 1
4000a1a4: 02 80 00 0b be 4000a1d0 <_CORE_RWLock_Release+0xa4> <== NEVER TAKEN
4000a1a8: 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;
4000a1ac: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000a1b0: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
4000a1b4: 40 00 08 dd call 4000c528 <_Thread_queue_Extract>
4000a1b8: 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 );
4000a1bc: 40 00 09 2c call 4000c66c <_Thread_queue_First>
4000a1c0: 90 10 00 18 mov %i0, %o0
if ( !next ||
4000a1c4: 92 92 20 00 orcc %o0, 0, %o1
4000a1c8: 32 bf ff f6 bne,a 4000a1a0 <_CORE_RWLock_Release+0x74>
4000a1cc: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000a1d0: 81 c7 e0 08 ret
4000a1d4: 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;
4000a1d8: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
4000a1dc: 80 a0 60 00 cmp %g1, 0
4000a1e0: 02 bf ff de be 4000a158 <_CORE_RWLock_Release+0x2c>
4000a1e4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
4000a1e8: 7f ff e4 9d call 4000345c <sparc_enable_interrupts>
4000a1ec: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
4000a1f0: 30 80 00 05 b,a 4000a204 <_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 );
4000a1f4: 7f ff e4 9a call 4000345c <sparc_enable_interrupts>
4000a1f8: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
4000a1fc: 82 10 20 02 mov 2, %g1
4000a200: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000a204: 81 c7 e0 08 ret
4000a208: 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;
4000a20c: 82 10 20 02 mov 2, %g1
4000a210: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000a214: 81 c7 e0 08 ret
4000a218: 91 e8 20 00 restore %g0, 0, %o0
4000a21c <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
4000a21c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000a220: 90 10 00 18 mov %i0, %o0
4000a224: 40 00 06 e4 call 4000bdb4 <_Thread_Get>
4000a228: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000a22c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a230: 80 a0 60 00 cmp %g1, 0
4000a234: 12 80 00 08 bne 4000a254 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
4000a238: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000a23c: 40 00 09 4d call 4000c770 <_Thread_queue_Process_timeout>
4000a240: 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;
4000a244: 03 10 00 69 sethi %hi(0x4001a400), %g1
4000a248: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 4001a7e0 <_Thread_Dispatch_disable_level>
--level;
4000a24c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000a250: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
4000a254: 81 c7 e0 08 ret
4000a258: 81 e8 00 00 restore
4000811c <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
4000811c: 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 )
40008120: 3b 10 00 7b sethi %hi(0x4001ec00), %i5
40008124: c2 07 62 c0 ld [ %i5 + 0x2c0 ], %g1 ! 4001eec0 <_Thread_Dispatch_disable_level>
40008128: 80 a0 60 00 cmp %g1, 0
4000812c: 02 80 00 1f be 400081a8 <_CORE_mutex_Seize+0x8c>
40008130: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
40008134: 80 a6 a0 00 cmp %i2, 0
40008138: 02 80 00 2c be 400081e8 <_CORE_mutex_Seize+0xcc>
4000813c: 90 10 00 18 mov %i0, %o0
40008140: 03 10 00 7c sethi %hi(0x4001f000), %g1
40008144: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 4001f3c8 <_System_state_Current>
40008148: 80 a0 60 01 cmp %g1, 1
4000814c: 38 80 00 2e bgu,a 40008204 <_CORE_mutex_Seize+0xe8>
40008150: 90 10 20 00 clr %o0
40008154: 40 00 14 6a call 4000d2fc <_CORE_mutex_Seize_interrupt_trylock>
40008158: 92 07 a0 54 add %fp, 0x54, %o1
4000815c: 80 a2 20 00 cmp %o0, 0
40008160: 02 80 00 27 be 400081fc <_CORE_mutex_Seize+0xe0> <== ALWAYS TAKEN
40008164: 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;
40008168: c4 07 62 c0 ld [ %i5 + 0x2c0 ], %g2
4000816c: 03 10 00 7c sethi %hi(0x4001f000), %g1
40008170: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 4001f3e0 <_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;
40008174: 86 10 20 01 mov 1, %g3
40008178: c6 26 20 30 st %g3, [ %i0 + 0x30 ]
4000817c: f0 20 60 44 st %i0, [ %g1 + 0x44 ]
40008180: f2 20 60 20 st %i1, [ %g1 + 0x20 ]
++level;
40008184: 82 00 a0 01 add %g2, 1, %g1
_Thread_Dispatch_disable_level = level;
40008188: c2 27 62 c0 st %g1, [ %i5 + 0x2c0 ]
4000818c: 7f ff e7 ca call 400020b4 <sparc_enable_interrupts>
40008190: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
40008194: 90 10 00 18 mov %i0, %o0
40008198: 7f ff ff ba call 40008080 <_CORE_mutex_Seize_interrupt_blocking>
4000819c: 92 10 00 1b mov %i3, %o1
400081a0: 81 c7 e0 08 ret
400081a4: 81 e8 00 00 restore
400081a8: 90 10 00 18 mov %i0, %o0
400081ac: 40 00 14 54 call 4000d2fc <_CORE_mutex_Seize_interrupt_trylock>
400081b0: 92 07 a0 54 add %fp, 0x54, %o1
400081b4: 80 a2 20 00 cmp %o0, 0
400081b8: 02 bf ff fa be 400081a0 <_CORE_mutex_Seize+0x84>
400081bc: 80 a6 a0 00 cmp %i2, 0
400081c0: 12 bf ff ea bne 40008168 <_CORE_mutex_Seize+0x4c>
400081c4: 01 00 00 00 nop
400081c8: 7f ff e7 bb call 400020b4 <sparc_enable_interrupts>
400081cc: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
400081d0: 03 10 00 7c sethi %hi(0x4001f000), %g1
400081d4: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 4001f3e0 <_Per_CPU_Information+0x10>
400081d8: 84 10 20 01 mov 1, %g2
400081dc: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
400081e0: 81 c7 e0 08 ret
400081e4: 81 e8 00 00 restore
400081e8: 40 00 14 45 call 4000d2fc <_CORE_mutex_Seize_interrupt_trylock>
400081ec: 92 07 a0 54 add %fp, 0x54, %o1
400081f0: 80 a2 20 00 cmp %o0, 0
400081f4: 12 bf ff f5 bne 400081c8 <_CORE_mutex_Seize+0xac> <== NEVER TAKEN
400081f8: 01 00 00 00 nop
400081fc: 81 c7 e0 08 ret
40008200: 81 e8 00 00 restore
40008204: 92 10 20 00 clr %o1
40008208: 40 00 01 c1 call 4000890c <_Internal_error_Occurred>
4000820c: 94 10 20 12 mov 0x12, %o2
4000838c <_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
)
{
4000838c: 9d e3 bf a0 save %sp, -96, %sp
40008390: ba 10 00 18 mov %i0, %i5
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
40008394: b0 10 20 00 clr %i0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
40008398: 40 00 07 a5 call 4000a22c <_Thread_queue_Dequeue>
4000839c: 90 10 00 1d mov %i5, %o0
400083a0: 80 a2 20 00 cmp %o0, 0
400083a4: 02 80 00 04 be 400083b4 <_CORE_semaphore_Surrender+0x28>
400083a8: 01 00 00 00 nop
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
400083ac: 81 c7 e0 08 ret
400083b0: 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 );
400083b4: 7f ff e7 3c call 400020a4 <sparc_disable_interrupts>
400083b8: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
400083bc: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
400083c0: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
400083c4: 80 a0 40 02 cmp %g1, %g2
400083c8: 1a 80 00 05 bcc 400083dc <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN
400083cc: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
400083d0: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
400083d4: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
400083d8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
400083dc: 7f ff e7 36 call 400020b4 <sparc_enable_interrupts>
400083e0: 01 00 00 00 nop
}
return status;
}
400083e4: 81 c7 e0 08 ret
400083e8: 81 e8 00 00 restore
40007f4c <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
40007f4c: 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;
40007f50: 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 );
40007f54: ba 06 20 04 add %i0, 4, %i5
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
40007f58: 80 a6 a0 00 cmp %i2, 0
40007f5c: 02 80 00 13 be 40007fa8 <_Chain_Initialize+0x5c> <== NEVER TAKEN
40007f60: 92 06 bf ff add %i2, -1, %o1
40007f64: 86 10 00 09 mov %o1, %g3
40007f68: 82 10 00 19 mov %i1, %g1
40007f6c: 84 10 00 18 mov %i0, %g2
current->next = next;
40007f70: c2 20 80 00 st %g1, [ %g2 ]
next->previous = current;
40007f74: c4 20 60 04 st %g2, [ %g1 + 4 ]
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
40007f78: 86 00 ff ff add %g3, -1, %g3
40007f7c: 84 10 00 01 mov %g1, %g2
40007f80: 80 a0 ff ff cmp %g3, -1
40007f84: 12 bf ff fb bne 40007f70 <_Chain_Initialize+0x24>
40007f88: 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(
40007f8c: 40 00 42 00 call 4001878c <.umul>
40007f90: 90 10 00 1b mov %i3, %o0
40007f94: 90 06 40 08 add %i1, %o0, %o0
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
40007f98: fa 22 00 00 st %i5, [ %o0 ]
tail->previous = current;
40007f9c: d0 26 20 08 st %o0, [ %i0 + 8 ]
40007fa0: 81 c7 e0 08 ret
40007fa4: 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;
40007fa8: 10 bf ff fc b 40007f98 <_Chain_Initialize+0x4c> <== NOT EXECUTED
40007fac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006ef8 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
40006ef8: 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 );
40006efc: 7f ff ec 6a call 400020a4 <sparc_disable_interrupts>
40006f00: 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;
40006f04: c2 06 80 00 ld [ %i2 ], %g1
40006f08: b2 16 40 01 or %i1, %g1, %i1
40006f0c: 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;
40006f10: 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 ) ) {
40006f14: 84 8e 40 01 andcc %i1, %g1, %g2
40006f18: 02 80 00 35 be 40006fec <_Event_Surrender+0xf4>
40006f1c: 07 10 00 7c sethi %hi(0x4001f000), %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() &&
40006f20: 86 10 e3 d0 or %g3, 0x3d0, %g3 ! 4001f3d0 <_Per_CPU_Information>
40006f24: c8 00 e0 08 ld [ %g3 + 8 ], %g4
40006f28: 80 a1 20 00 cmp %g4, 0
40006f2c: 32 80 00 1c bne,a 40006f9c <_Event_Surrender+0xa4>
40006f30: 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);
40006f34: 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 ) ) {
40006f38: 80 8f 00 03 btst %i4, %g3
40006f3c: 02 80 00 2c be 40006fec <_Event_Surrender+0xf4>
40006f40: 80 a0 40 02 cmp %g1, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40006f44: 02 80 00 04 be 40006f54 <_Event_Surrender+0x5c>
40006f48: 80 8f 60 02 btst 2, %i5
40006f4c: 02 80 00 28 be 40006fec <_Event_Surrender+0xf4> <== NEVER TAKEN
40006f50: 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;
40006f54: 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) );
40006f58: 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(
40006f5c: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40006f60: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006f64: c4 20 40 00 st %g2, [ %g1 ]
_ISR_Flash( level );
40006f68: 7f ff ec 53 call 400020b4 <sparc_enable_interrupts>
40006f6c: 01 00 00 00 nop
40006f70: 7f ff ec 4d call 400020a4 <sparc_disable_interrupts>
40006f74: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
40006f78: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
40006f7c: 80 a0 60 02 cmp %g1, 2
40006f80: 02 80 00 1d be 40006ff4 <_Event_Surrender+0xfc>
40006f84: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
40006f88: 7f ff ec 4b call 400020b4 <sparc_enable_interrupts>
40006f8c: 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 );
40006f90: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
40006f94: 40 00 0a e0 call 40009b14 <_Thread_Clear_state>
40006f98: 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() &&
40006f9c: 80 a6 00 03 cmp %i0, %g3
40006fa0: 32 bf ff e6 bne,a 40006f38 <_Event_Surrender+0x40>
40006fa4: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
40006fa8: c6 06 c0 00 ld [ %i3 ], %g3
40006fac: 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 ) &&
40006fb0: 80 a0 e0 01 cmp %g3, 1
40006fb4: 38 bf ff e1 bgu,a 40006f38 <_Event_Surrender+0x40>
40006fb8: 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) ) {
40006fbc: 80 a0 40 02 cmp %g1, %g2
40006fc0: 02 80 00 04 be 40006fd0 <_Event_Surrender+0xd8>
40006fc4: 80 8f 60 02 btst 2, %i5
40006fc8: 02 80 00 09 be 40006fec <_Event_Surrender+0xf4> <== NEVER TAKEN
40006fcc: 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;
40006fd0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
40006fd4: 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(
40006fd8: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40006fdc: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006fe0: c4 20 40 00 st %g2, [ %g1 ]
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
40006fe4: 82 10 20 03 mov 3, %g1
40006fe8: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
40006fec: 7f ff ec 32 call 400020b4 <sparc_enable_interrupts>
40006ff0: 91 e8 00 08 restore %g0, %o0, %o0
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
40006ff4: 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 );
40006ff8: 7f ff ec 2f call 400020b4 <sparc_enable_interrupts>
40006ffc: 33 04 01 ff sethi %hi(0x1007fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
40007000: 40 00 0f 4d call 4000ad34 <_Watchdog_Remove>
40007004: 90 06 20 48 add %i0, 0x48, %o0
40007008: b2 16 63 f8 or %i1, 0x3f8, %i1
4000700c: 40 00 0a c2 call 40009b14 <_Thread_Clear_state>
40007010: 81 e8 00 00 restore
40007014 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
40007014: 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 );
40007018: 90 10 00 18 mov %i0, %o0
4000701c: 40 00 0b b7 call 40009ef8 <_Thread_Get>
40007020: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40007024: c2 07 bf fc ld [ %fp + -4 ], %g1
40007028: 80 a0 60 00 cmp %g1, 0
4000702c: 12 80 00 15 bne 40007080 <_Event_Timeout+0x6c> <== NEVER TAKEN
40007030: 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 );
40007034: 7f ff ec 1c call 400020a4 <sparc_disable_interrupts>
40007038: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
4000703c: 03 10 00 7c sethi %hi(0x4001f000), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
40007040: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 4001f3e0 <_Per_CPU_Information+0x10>
40007044: 80 a7 40 01 cmp %i5, %g1
40007048: 02 80 00 10 be 40007088 <_Event_Timeout+0x74>
4000704c: 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;
40007050: 82 10 20 06 mov 6, %g1
40007054: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
40007058: 7f ff ec 17 call 400020b4 <sparc_enable_interrupts>
4000705c: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40007060: 90 10 00 1d mov %i5, %o0
40007064: 13 04 01 ff sethi %hi(0x1007fc00), %o1
40007068: 40 00 0a ab call 40009b14 <_Thread_Clear_state>
4000706c: 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;
40007070: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40007074: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 4001eec0 <_Thread_Dispatch_disable_level>
--level;
40007078: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000707c: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
40007080: 81 c7 e0 08 ret
40007084: 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 )
40007088: c2 06 40 00 ld [ %i1 ], %g1
4000708c: 80 a0 60 01 cmp %g1, 1
40007090: 12 bf ff f1 bne 40007054 <_Event_Timeout+0x40>
40007094: 82 10 20 06 mov 6, %g1
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
40007098: 82 10 20 02 mov 2, %g1
4000709c: 10 bf ff ed b 40007050 <_Event_Timeout+0x3c>
400070a0: c2 26 40 00 st %g1, [ %i1 ]
4000d45c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
4000d45c: 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
4000d460: a2 06 60 04 add %i1, 4, %l1
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
4000d464: 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 ) {
4000d468: 80 a6 40 11 cmp %i1, %l1
4000d46c: 18 80 00 85 bgu 4000d680 <_Heap_Allocate_aligned_with_boundary+0x224>
4000d470: ea 06 20 10 ld [ %i0 + 0x10 ], %l5
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
4000d474: 80 a6 e0 00 cmp %i3, 0
4000d478: 12 80 00 7c bne 4000d668 <_Heap_Allocate_aligned_with_boundary+0x20c>
4000d47c: 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;
4000d480: 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 ) {
4000d484: 80 a4 00 1d cmp %l0, %i5
4000d488: 02 80 00 18 be 4000d4e8 <_Heap_Allocate_aligned_with_boundary+0x8c>
4000d48c: 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;
4000d490: 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
4000d494: ae 05 60 07 add %l5, 7, %l7
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
4000d498: ac 25 80 19 sub %l6, %i1, %l6
4000d49c: 10 80 00 0b b 4000d4c8 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000d4a0: 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 ) {
4000d4a4: 12 80 00 18 bne 4000d504 <_Heap_Allocate_aligned_with_boundary+0xa8>
4000d4a8: b0 07 60 08 add %i5, 8, %i0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
4000d4ac: 80 a6 20 00 cmp %i0, 0
4000d4b0: 12 80 00 4d bne 4000d5e4 <_Heap_Allocate_aligned_with_boundary+0x188><== ALWAYS TAKEN
4000d4b4: b8 07 20 01 inc %i4
break;
}
block = block->next;
4000d4b8: 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 ) {
4000d4bc: 80 a4 00 1d cmp %l0, %i5
4000d4c0: 22 80 00 0b be,a 4000d4ec <_Heap_Allocate_aligned_with_boundary+0x90>
4000d4c4: 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 ) {
4000d4c8: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000d4cc: 80 a4 40 01 cmp %l1, %g1
4000d4d0: 0a bf ff f5 bcs 4000d4a4 <_Heap_Allocate_aligned_with_boundary+0x48>
4000d4d4: 80 a6 a0 00 cmp %i2, 0
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
4000d4d8: 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 ) {
4000d4dc: 80 a4 00 1d cmp %l0, %i5
4000d4e0: 12 bf ff fa bne 4000d4c8 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000d4e4: b8 07 20 01 inc %i4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
4000d4e8: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
4000d4ec: 80 a0 40 1c cmp %g1, %i4
4000d4f0: 1a 80 00 03 bcc 4000d4fc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000d4f4: b0 10 20 00 clr %i0
stats->max_search = search_count;
4000d4f8: f8 24 20 44 st %i4, [ %l0 + 0x44 ]
}
return (void *) alloc_begin;
4000d4fc: 81 c7 e0 08 ret
4000d500: 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;
4000d504: 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;
4000d508: 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;
4000d50c: 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;
4000d510: 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;
4000d514: 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);
4000d518: 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;
4000d51c: 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
4000d520: a4 00 80 12 add %g2, %l2, %l2
4000d524: 40 00 2d 80 call 40018b24 <.urem>
4000d528: 90 10 00 18 mov %i0, %o0
4000d52c: 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 ) {
4000d530: 80 a4 80 18 cmp %l2, %i0
4000d534: 1a 80 00 06 bcc 4000d54c <_Heap_Allocate_aligned_with_boundary+0xf0>
4000d538: a6 07 60 08 add %i5, 8, %l3
4000d53c: 90 10 00 12 mov %l2, %o0
4000d540: 40 00 2d 79 call 40018b24 <.urem>
4000d544: 92 10 00 1a mov %i2, %o1
4000d548: b0 24 80 08 sub %l2, %o0, %i0
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
4000d54c: 80 a6 e0 00 cmp %i3, 0
4000d550: 02 80 00 37 be 4000d62c <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000d554: 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;
4000d558: 86 06 00 19 add %i0, %i1, %g3
4000d55c: 92 10 00 1b mov %i3, %o1
4000d560: 90 10 00 03 mov %g3, %o0
4000d564: 40 00 2d 70 call 40018b24 <.urem>
4000d568: c6 27 bf f8 st %g3, [ %fp + -8 ]
4000d56c: c6 07 bf f8 ld [ %fp + -8 ], %g3
4000d570: 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 ) {
4000d574: 80 a6 00 08 cmp %i0, %o0
4000d578: 1a 80 00 2c bcc 4000d628 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d57c: a4 04 c0 19 add %l3, %i1, %l2
4000d580: 80 a2 00 03 cmp %o0, %g3
4000d584: 2a 80 00 12 bcs,a 4000d5cc <_Heap_Allocate_aligned_with_boundary+0x170>
4000d588: 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 ) {
4000d58c: 10 80 00 28 b 4000d62c <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000d590: 80 a4 c0 18 cmp %l3, %i0
4000d594: 92 10 00 1a mov %i2, %o1
4000d598: 40 00 2d 63 call 40018b24 <.urem>
4000d59c: 90 10 00 18 mov %i0, %o0
4000d5a0: 92 10 00 1b mov %i3, %o1
4000d5a4: 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;
4000d5a8: ac 06 00 19 add %i0, %i1, %l6
4000d5ac: 40 00 2d 5e call 40018b24 <.urem>
4000d5b0: 90 10 00 16 mov %l6, %o0
4000d5b4: 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 ) {
4000d5b8: 80 a2 00 16 cmp %o0, %l6
4000d5bc: 1a 80 00 1b bcc 4000d628 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d5c0: 80 a6 00 08 cmp %i0, %o0
4000d5c4: 1a 80 00 19 bcc 4000d628 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d5c8: 80 a4 80 08 cmp %l2, %o0
if ( boundary_line < boundary_floor ) {
4000d5cc: 08 bf ff f2 bleu 4000d594 <_Heap_Allocate_aligned_with_boundary+0x138>
4000d5d0: b0 22 00 19 sub %o0, %i1, %i0
return 0;
4000d5d4: b0 10 20 00 clr %i0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
4000d5d8: 80 a6 20 00 cmp %i0, 0
4000d5dc: 02 bf ff b7 be 4000d4b8 <_Heap_Allocate_aligned_with_boundary+0x5c><== ALWAYS TAKEN
4000d5e0: 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;
4000d5e4: c6 04 20 48 ld [ %l0 + 0x48 ], %g3
stats->searches += search_count;
4000d5e8: 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;
4000d5ec: 86 00 e0 01 inc %g3
stats->searches += search_count;
4000d5f0: 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;
4000d5f4: c6 24 20 48 st %g3, [ %l0 + 0x48 ]
stats->searches += search_count;
4000d5f8: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000d5fc: 90 10 00 10 mov %l0, %o0
4000d600: 92 10 00 1d mov %i5, %o1
4000d604: 94 10 00 18 mov %i0, %o2
4000d608: 7f ff ec 75 call 400087dc <_Heap_Block_allocate>
4000d60c: 96 10 00 19 mov %i1, %o3
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
4000d610: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
4000d614: 80 a0 40 1c cmp %g1, %i4
4000d618: 2a bf ff b9 bcs,a 4000d4fc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000d61c: f8 24 20 44 st %i4, [ %l0 + 0x44 ]
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
4000d620: 81 c7 e0 08 ret
4000d624: 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 ) {
4000d628: 80 a4 c0 18 cmp %l3, %i0
4000d62c: 18 bf ff ea bgu 4000d5d4 <_Heap_Allocate_aligned_with_boundary+0x178>
4000d630: 82 10 3f f8 mov -8, %g1
4000d634: 90 10 00 18 mov %i0, %o0
4000d638: a4 20 40 1d sub %g1, %i5, %l2
4000d63c: 92 10 00 15 mov %l5, %o1
4000d640: 40 00 2d 39 call 40018b24 <.urem>
4000d644: 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 ) {
4000d648: 90 a4 80 08 subcc %l2, %o0, %o0
4000d64c: 02 bf ff 99 be 4000d4b0 <_Heap_Allocate_aligned_with_boundary+0x54>
4000d650: 80 a6 20 00 cmp %i0, 0
4000d654: 80 a2 00 14 cmp %o0, %l4
4000d658: 1a bf ff 96 bcc 4000d4b0 <_Heap_Allocate_aligned_with_boundary+0x54>
4000d65c: 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;
4000d660: 10 bf ff de b 4000d5d8 <_Heap_Allocate_aligned_with_boundary+0x17c>
4000d664: b0 10 20 00 clr %i0
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
4000d668: 18 80 00 06 bgu 4000d680 <_Heap_Allocate_aligned_with_boundary+0x224>
4000d66c: 80 a6 a0 00 cmp %i2, 0
return NULL;
}
if ( alignment == 0 ) {
4000d670: 22 bf ff 84 be,a 4000d480 <_Heap_Allocate_aligned_with_boundary+0x24>
4000d674: 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;
4000d678: 10 bf ff 83 b 4000d484 <_Heap_Allocate_aligned_with_boundary+0x28>
4000d67c: 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;
4000d680: 81 c7 e0 08 ret
4000d684: 91 e8 20 00 restore %g0, 0, %o0
4000d29c <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
4000d29c: 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;
4000d2a0: c0 27 bf f8 clr [ %fp + -8 ]
Heap_Block *extend_last_block = NULL;
4000d2a4: 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))
)
{
4000d2a8: b8 10 00 18 mov %i0, %i4
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
4000d2ac: 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;
4000d2b0: 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;
4000d2b4: e4 06 20 10 ld [ %i0 + 0x10 ], %l2
uintptr_t const min_block_size = heap->min_block_size;
4000d2b8: 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 ) {
4000d2bc: 80 a6 40 10 cmp %i1, %l0
4000d2c0: 08 80 00 04 bleu 4000d2d0 <_Heap_Extend+0x34>
4000d2c4: f0 06 20 30 ld [ %i0 + 0x30 ], %i0
return 0;
4000d2c8: 81 c7 e0 08 ret
4000d2cc: 91 e8 20 00 restore %g0, 0, %o0
}
extend_area_ok = _Heap_Get_first_and_last_block(
4000d2d0: 90 10 00 19 mov %i1, %o0
4000d2d4: 92 10 00 1a mov %i2, %o1
4000d2d8: 94 10 00 12 mov %l2, %o2
4000d2dc: 98 07 bf f8 add %fp, -8, %o4
4000d2e0: 7f ff ec 06 call 400082f8 <_Heap_Get_first_and_last_block>
4000d2e4: 9a 07 bf fc add %fp, -4, %o5
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4000d2e8: 80 8a 20 ff btst 0xff, %o0
4000d2ec: 02 bf ff f7 be 4000d2c8 <_Heap_Extend+0x2c>
4000d2f0: ba 10 00 11 mov %l1, %i5
4000d2f4: aa 10 20 00 clr %l5
4000d2f8: ac 10 20 00 clr %l6
4000d2fc: a6 10 20 00 clr %l3
4000d300: 10 80 00 10 b 4000d340 <_Heap_Extend+0xa4>
4000d304: 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 ) {
4000d308: 2a 80 00 02 bcs,a 4000d310 <_Heap_Extend+0x74>
4000d30c: ac 10 00 1d mov %i5, %l6
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4000d310: 80 a6 c0 19 cmp %i3, %i1
4000d314: 22 80 00 1e be,a 4000d38c <_Heap_Extend+0xf0>
4000d318: 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 ) {
4000d31c: 80 a6 40 1b cmp %i1, %i3
4000d320: 38 80 00 02 bgu,a 4000d328 <_Heap_Extend+0x8c>
4000d324: 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;
4000d328: fa 02 20 04 ld [ %o0 + 4 ], %i5
4000d32c: 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);
4000d330: 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 );
4000d334: 80 a4 40 1d cmp %l1, %i5
4000d338: 22 80 00 1c be,a 4000d3a8 <_Heap_Extend+0x10c>
4000d33c: 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;
4000d340: 80 a7 40 11 cmp %i5, %l1
4000d344: 22 80 00 03 be,a 4000d350 <_Heap_Extend+0xb4>
4000d348: f4 07 20 18 ld [ %i4 + 0x18 ], %i2
4000d34c: b4 10 00 1d mov %i5, %i2
uintptr_t const sub_area_end = start_block->prev_size;
4000d350: 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);
4000d354: 92 10 00 12 mov %l2, %o1
4000d358: 40 00 17 1b call 40012fc4 <.urem>
4000d35c: 90 10 00 1b mov %i3, %o0
4000d360: 82 06 ff f8 add %i3, -8, %g1
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4000d364: 80 a6 80 10 cmp %i2, %l0
4000d368: 0a 80 00 64 bcs 4000d4f8 <_Heap_Extend+0x25c>
4000d36c: 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 ) {
4000d370: 80 a6 80 10 cmp %i2, %l0
4000d374: 12 bf ff e5 bne 4000d308 <_Heap_Extend+0x6c>
4000d378: 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 ) {
4000d37c: 80 a6 c0 19 cmp %i3, %i1
4000d380: 12 bf ff e7 bne 4000d31c <_Heap_Extend+0x80> <== ALWAYS TAKEN
4000d384: a8 10 00 1d mov %i5, %l4
start_block->prev_size = extend_area_end;
4000d388: 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;
4000d38c: fa 02 20 04 ld [ %o0 + 4 ], %i5
4000d390: 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);
4000d394: 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 );
4000d398: 80 a4 40 1d cmp %l1, %i5
4000d39c: 12 bf ff e9 bne 4000d340 <_Heap_Extend+0xa4> <== NEVER TAKEN
4000d3a0: a6 10 00 08 mov %o0, %l3
if ( extend_area_begin < heap->area_begin ) {
4000d3a4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
4000d3a8: 80 a6 40 01 cmp %i1, %g1
4000d3ac: 3a 80 00 4e bcc,a 4000d4e4 <_Heap_Extend+0x248>
4000d3b0: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
heap->area_begin = extend_area_begin;
4000d3b4: 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;
4000d3b8: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000d3bc: 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 ) {
4000d3c0: 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 =
4000d3c4: 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;
4000d3c8: e0 20 40 00 st %l0, [ %g1 ]
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4000d3cc: 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 =
4000d3d0: 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;
4000d3d4: 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 ) {
4000d3d8: 80 a1 00 01 cmp %g4, %g1
4000d3dc: 08 80 00 3c bleu 4000d4cc <_Heap_Extend+0x230>
4000d3e0: c0 20 a0 04 clr [ %g2 + 4 ]
heap->first_block = extend_first_block;
4000d3e4: 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 ) {
4000d3e8: 80 a5 20 00 cmp %l4, 0
4000d3ec: 02 80 00 47 be 4000d508 <_Heap_Extend+0x26c>
4000d3f0: 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;
4000d3f4: 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;
4000d3f8: 92 10 00 1d mov %i5, %o1
4000d3fc: 40 00 16 f2 call 40012fc4 <.urem>
4000d400: 90 10 00 19 mov %i1, %o0
if ( remainder != 0 ) {
4000d404: 80 a2 20 00 cmp %o0, 0
4000d408: 02 80 00 04 be 4000d418 <_Heap_Extend+0x17c>
4000d40c: c4 05 00 00 ld [ %l4 ], %g2
return value - remainder + alignment;
4000d410: b2 06 40 1d add %i1, %i5, %i1
4000d414: 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 =
4000d418: 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;
4000d41c: 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 =
4000d420: 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;
4000d424: 84 10 a0 01 or %g2, 1, %g2
_Heap_Free_block( heap, new_first_block );
4000d428: 90 10 00 1c mov %i4, %o0
4000d42c: 92 10 00 01 mov %g1, %o1
4000d430: 7f ff ff 85 call 4000d244 <_Heap_Free_block>
4000d434: c4 26 7f fc st %g2, [ %i1 + -4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4000d438: 80 a4 e0 00 cmp %l3, 0
4000d43c: 02 80 00 3a be 4000d524 <_Heap_Extend+0x288>
4000d440: 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);
4000d444: 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(
4000d448: a0 24 00 13 sub %l0, %l3, %l0
4000d44c: 40 00 16 de call 40012fc4 <.urem>
4000d450: 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)
4000d454: c2 04 e0 04 ld [ %l3 + 4 ], %g1
4000d458: a0 24 00 08 sub %l0, %o0, %l0
4000d45c: 82 20 40 10 sub %g1, %l0, %g1
| HEAP_PREV_BLOCK_USED;
4000d460: 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 =
4000d464: 84 04 00 13 add %l0, %l3, %g2
4000d468: 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;
4000d46c: 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 );
4000d470: 90 10 00 1c mov %i4, %o0
4000d474: 82 08 60 01 and %g1, 1, %g1
4000d478: 92 10 00 13 mov %l3, %o1
block->size_and_flag = size | flag;
4000d47c: a0 14 00 01 or %l0, %g1, %l0
4000d480: 7f ff ff 71 call 4000d244 <_Heap_Free_block>
4000d484: e0 24 e0 04 st %l0, [ %l3 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4000d488: 80 a4 e0 00 cmp %l3, 0
4000d48c: 02 80 00 33 be 4000d558 <_Heap_Extend+0x2bc>
4000d490: 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
4000d494: 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(
4000d498: 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;
4000d49c: 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;
4000d4a0: 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;
4000d4a4: 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(
4000d4a8: 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;
4000d4ac: 88 09 20 01 and %g4, 1, %g4
block->size_and_flag = size | flag;
4000d4b0: 88 17 40 04 or %i5, %g4, %g4
4000d4b4: c8 20 60 04 st %g4, [ %g1 + 4 ]
4000d4b8: b0 20 c0 18 sub %g3, %i0, %i0
/* Statistics */
stats->size += extended_size;
4000d4bc: 82 00 80 18 add %g2, %i0, %g1
4000d4c0: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
return extended_size;
}
4000d4c4: 81 c7 e0 08 ret
4000d4c8: 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 ) {
4000d4cc: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000d4d0: 80 a0 40 02 cmp %g1, %g2
4000d4d4: 2a bf ff c5 bcs,a 4000d3e8 <_Heap_Extend+0x14c>
4000d4d8: c4 27 20 24 st %g2, [ %i4 + 0x24 ]
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
4000d4dc: 10 bf ff c4 b 4000d3ec <_Heap_Extend+0x150>
4000d4e0: 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 ) {
4000d4e4: 80 a4 00 01 cmp %l0, %g1
4000d4e8: 38 bf ff b4 bgu,a 4000d3b8 <_Heap_Extend+0x11c>
4000d4ec: 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;
4000d4f0: 10 bf ff b3 b 4000d3bc <_Heap_Extend+0x120>
4000d4f4: 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 (
4000d4f8: 80 a6 40 1b cmp %i1, %i3
4000d4fc: 1a bf ff 9e bcc 4000d374 <_Heap_Extend+0xd8>
4000d500: 80 a6 80 10 cmp %i2, %l0
4000d504: 30 bf ff 71 b,a 4000d2c8 <_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 ) {
4000d508: 80 a5 a0 00 cmp %l6, 0
4000d50c: 02 bf ff cc be 4000d43c <_Heap_Extend+0x1a0>
4000d510: 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;
4000d514: ac 25 80 02 sub %l6, %g2, %l6
4000d518: 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 =
4000d51c: 10 bf ff c8 b 4000d43c <_Heap_Extend+0x1a0>
4000d520: 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 ) {
4000d524: 80 a5 60 00 cmp %l5, 0
4000d528: 02 bf ff d8 be 4000d488 <_Heap_Extend+0x1ec>
4000d52c: 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;
4000d530: c6 05 60 04 ld [ %l5 + 4 ], %g3
_Heap_Link_above(
4000d534: c2 07 bf fc ld [ %fp + -4 ], %g1
4000d538: 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 );
4000d53c: 84 20 80 15 sub %g2, %l5, %g2
block->size_and_flag = size | flag;
4000d540: 84 10 80 03 or %g2, %g3, %g2
4000d544: c4 25 60 04 st %g2, [ %l5 + 4 ]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4000d548: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000d54c: 84 10 a0 01 or %g2, 1, %g2
4000d550: 10 bf ff ce b 4000d488 <_Heap_Extend+0x1ec>
4000d554: c4 20 60 04 st %g2, [ %g1 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4000d558: 32 bf ff d0 bne,a 4000d498 <_Heap_Extend+0x1fc>
4000d55c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
_Heap_Free_block( heap, extend_first_block );
4000d560: d2 07 bf f8 ld [ %fp + -8 ], %o1
4000d564: 7f ff ff 38 call 4000d244 <_Heap_Free_block>
4000d568: 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
4000d56c: 10 bf ff cb b 4000d498 <_Heap_Extend+0x1fc>
4000d570: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000d688 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4000d688: 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 ) {
4000d68c: 80 a6 60 00 cmp %i1, 0
4000d690: 02 80 00 3c be 4000d780 <_Heap_Free+0xf8>
4000d694: 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);
4000d698: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4000d69c: 40 00 2d 22 call 40018b24 <.urem>
4000d6a0: 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
4000d6a4: 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);
4000d6a8: 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);
4000d6ac: 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;
4000d6b0: 80 a2 00 02 cmp %o0, %g2
4000d6b4: 0a 80 00 30 bcs 4000d774 <_Heap_Free+0xec>
4000d6b8: 82 10 20 00 clr %g1
4000d6bc: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
4000d6c0: 80 a2 00 04 cmp %o0, %g4
4000d6c4: 38 80 00 2d bgu,a 4000d778 <_Heap_Free+0xf0> <== NEVER TAKEN
4000d6c8: 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;
4000d6cc: f6 02 20 04 ld [ %o0 + 4 ], %i3
4000d6d0: 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);
4000d6d4: 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;
4000d6d8: 80 a0 80 03 cmp %g2, %g3
4000d6dc: 38 80 00 27 bgu,a 4000d778 <_Heap_Free+0xf0> <== NEVER TAKEN
4000d6e0: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
4000d6e4: 80 a1 00 03 cmp %g4, %g3
4000d6e8: 2a 80 00 24 bcs,a 4000d778 <_Heap_Free+0xf0> <== NEVER TAKEN
4000d6ec: 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;
4000d6f0: f8 00 e0 04 ld [ %g3 + 4 ], %i4
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4000d6f4: 80 8f 20 01 btst 1, %i4
4000d6f8: 02 80 00 1f be 4000d774 <_Heap_Free+0xec> <== NEVER TAKEN
4000d6fc: 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 ));
4000d700: 02 80 00 23 be 4000d78c <_Heap_Free+0x104>
4000d704: b8 0f 3f fe and %i4, -2, %i4
4000d708: 82 00 c0 1c add %g3, %i4, %g1
4000d70c: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000d710: 80 88 60 01 btst 1, %g1
4000d714: 12 80 00 1f bne 4000d790 <_Heap_Free+0x108>
4000d718: 80 8e e0 01 btst 1, %i3
if ( !_Heap_Is_prev_used( block ) ) {
4000d71c: 02 80 00 20 be 4000d79c <_Heap_Free+0x114>
4000d720: 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;
4000d724: c4 00 e0 08 ld [ %g3 + 8 ], %g2
Heap_Block *prev = old_block->prev;
4000d728: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
new_block->next = next;
4000d72c: c4 22 20 08 st %g2, [ %o0 + 8 ]
new_block->prev = prev;
4000d730: 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;
4000d734: b8 07 00 1d add %i4, %i5, %i4
next->prev = new_block;
4000d738: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
prev->next = new_block;
4000d73c: d0 20 60 08 st %o0, [ %g1 + 8 ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000d740: 84 17 20 01 or %i4, 1, %g2
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4000d744: 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;
4000d748: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
4000d74c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
4000d750: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
++stats->frees;
stats->free_size += block_size;
4000d754: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
4000d758: 82 00 60 01 inc %g1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
4000d75c: 84 00 bf ff add %g2, -1, %g2
++stats->frees;
stats->free_size += block_size;
4000d760: ba 00 c0 1d add %g3, %i5, %i5
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
4000d764: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
4000d768: c4 26 20 40 st %g2, [ %i0 + 0x40 ]
++stats->frees;
stats->free_size += block_size;
4000d76c: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
return( true );
4000d770: 82 10 20 01 mov 1, %g1
4000d774: b0 08 60 ff and %g1, 0xff, %i0
4000d778: 81 c7 e0 08 ret
4000d77c: 81 e8 00 00 restore
4000d780: b0 08 60 ff and %g1, 0xff, %i0
4000d784: 81 c7 e0 08 ret
4000d788: 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 ) ) {
4000d78c: 80 8e e0 01 btst 1, %i3
4000d790: 32 80 00 1e bne,a 4000d808 <_Heap_Free+0x180>
4000d794: 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
4000d798: 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;
4000d79c: 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);
4000d7a0: 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;
4000d7a4: 80 a0 80 1b cmp %g2, %i3
4000d7a8: 18 bf ff f3 bgu 4000d774 <_Heap_Free+0xec> <== NEVER TAKEN
4000d7ac: 82 10 20 00 clr %g1
4000d7b0: 80 a1 00 1b cmp %g4, %i3
4000d7b4: 2a bf ff f1 bcs,a 4000d778 <_Heap_Free+0xf0> <== NEVER TAKEN
4000d7b8: 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;
4000d7bc: 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) ) {
4000d7c0: 80 88 a0 01 btst 1, %g2
4000d7c4: 02 bf ff ec be 4000d774 <_Heap_Free+0xec> <== NEVER TAKEN
4000d7c8: 80 8e 60 ff btst 0xff, %i1
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4000d7cc: 22 80 00 21 be,a 4000d850 <_Heap_Free+0x1c8>
4000d7d0: 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;
4000d7d4: c2 00 e0 08 ld [ %g3 + 8 ], %g1
Heap_Block *prev = block->prev;
4000d7d8: 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;
4000d7dc: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
prev->next = next;
4000d7e0: c2 20 a0 08 st %g1, [ %g2 + 8 ]
next->prev = prev;
4000d7e4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
4000d7e8: 82 00 ff ff add %g3, -1, %g1
4000d7ec: 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;
4000d7f0: b8 07 40 1c add %i5, %i4, %i4
4000d7f4: 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;
4000d7f8: 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;
4000d7fc: 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;
4000d800: 10 bf ff d3 b 4000d74c <_Heap_Free+0xc4>
4000d804: 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;
4000d808: 82 17 60 01 or %i5, 1, %g1
4000d80c: c2 22 20 04 st %g1, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000d810: c8 00 e0 04 ld [ %g3 + 4 ], %g4
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
4000d814: f0 22 20 0c st %i0, [ %o0 + 0xc ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4000d818: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4000d81c: c4 22 20 08 st %g2, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
4000d820: 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;
4000d824: 84 09 3f fe and %g4, -2, %g2
next_block->prev_size = block_size;
4000d828: 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;
4000d82c: 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 ) {
4000d830: 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;
4000d834: 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;
4000d838: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
4000d83c: 80 a0 40 02 cmp %g1, %g2
4000d840: 08 bf ff c3 bleu 4000d74c <_Heap_Free+0xc4>
4000d844: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
4000d848: 10 bf ff c1 b 4000d74c <_Heap_Free+0xc4>
4000d84c: 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;
4000d850: 82 16 a0 01 or %i2, 1, %g1
4000d854: c2 26 e0 04 st %g1, [ %i3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000d858: c2 00 e0 04 ld [ %g3 + 4 ], %g1
next_block->prev_size = size;
4000d85c: 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;
4000d860: 82 08 7f fe and %g1, -2, %g1
4000d864: 10 bf ff ba b 4000d74c <_Heap_Free+0xc4>
4000d868: c2 20 e0 04 st %g1, [ %g3 + 4 ]
40013354 <_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;
40013354: 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;
40013358: c0 22 40 00 clr [ %o1 ]
info->largest = 0;
4001335c: c0 22 60 04 clr [ %o1 + 4 ]
info->total = 0;
40013360: c0 22 60 08 clr [ %o1 + 8 ]
for(the_block = _Heap_Free_list_first(the_heap);
40013364: 88 10 20 01 mov 1, %g4
40013368: 9a 10 20 00 clr %o5
4001336c: 80 a2 00 01 cmp %o0, %g1
40013370: 12 80 00 04 bne 40013380 <_Heap_Get_free_information+0x2c><== ALWAYS TAKEN
40013374: 86 10 20 00 clr %g3
40013378: 30 80 00 10 b,a 400133b8 <_Heap_Get_free_information+0x64><== NOT EXECUTED
4001337c: 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;
40013380: c4 00 60 04 ld [ %g1 + 4 ], %g2
40013384: 98 01 20 01 add %g4, 1, %o4
40013388: 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 )
4001338c: 80 a0 80 0d cmp %g2, %o5
40013390: 08 80 00 03 bleu 4001339c <_Heap_Get_free_information+0x48>
40013394: 86 00 c0 02 add %g3, %g2, %g3
info->largest = the_size;
40013398: 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)
4001339c: 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);
400133a0: 80 a2 00 01 cmp %o0, %g1
400133a4: 32 bf ff f6 bne,a 4001337c <_Heap_Get_free_information+0x28>
400133a8: da 02 60 04 ld [ %o1 + 4 ], %o5
400133ac: c8 22 40 00 st %g4, [ %o1 ]
400133b0: 81 c3 e0 08 retl
400133b4: c6 22 60 08 st %g3, [ %o1 + 8 ]
400133b8: 81 c3 e0 08 retl <== NOT EXECUTED
4000a3f8 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
4000a3f8: 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) {
4000a3fc: 80 a6 a0 00 cmp %i2, 0
4000a400: 02 80 00 35 be 4000a4d4 <_Heap_Greedy_allocate+0xdc>
4000a404: b8 10 00 18 mov %i0, %i4
4000a408: ba 10 20 00 clr %i5
4000a40c: b6 10 20 00 clr %i3
#include "config.h"
#endif
#include <rtems/score/heap.h>
Heap_Block *_Heap_Greedy_allocate(
4000a410: 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 );
4000a414: d2 06 40 01 ld [ %i1 + %g1 ], %o1
4000a418: 94 10 20 00 clr %o2
4000a41c: 96 10 20 00 clr %o3
4000a420: 40 00 1f 3e call 40012118 <_Heap_Allocate_aligned_with_boundary>
4000a424: 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 ) {
4000a428: 82 92 20 00 orcc %o0, 0, %g1
4000a42c: 22 80 00 09 be,a 4000a450 <_Heap_Greedy_allocate+0x58> <== NEVER TAKEN
4000a430: 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);
4000a434: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
4000a438: 40 00 36 a8 call 40017ed8 <.urem>
4000a43c: 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);
4000a440: 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;
4000a444: f6 22 20 08 st %i3, [ %o0 + 8 ]
4000a448: 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) {
4000a44c: ba 07 60 01 inc %i5
4000a450: 80 a7 40 1a cmp %i5, %i2
4000a454: 12 bf ff f0 bne 4000a414 <_Heap_Greedy_allocate+0x1c>
4000a458: 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;
4000a45c: 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 ) {
4000a460: 80 a7 00 1d cmp %i4, %i5
4000a464: 02 80 00 17 be 4000a4c0 <_Heap_Greedy_allocate+0xc8> <== NEVER TAKEN
4000a468: b0 10 20 00 clr %i0
4000a46c: 10 80 00 03 b 4000a478 <_Heap_Greedy_allocate+0x80>
4000a470: b4 10 20 00 clr %i2
4000a474: 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;
4000a478: d6 07 60 04 ld [ %i5 + 4 ], %o3
_Heap_Block_allocate(
4000a47c: 92 10 00 1d mov %i5, %o1
4000a480: 96 0a ff fe and %o3, -2, %o3
4000a484: 94 07 60 08 add %i5, 8, %o2
4000a488: 90 10 00 1c mov %i4, %o0
4000a48c: 40 00 00 e0 call 4000a80c <_Heap_Block_allocate>
4000a490: 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;
4000a494: 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;
4000a498: 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 ) {
4000a49c: 80 a7 00 01 cmp %i4, %g1
4000a4a0: 12 bf ff f5 bne 4000a474 <_Heap_Greedy_allocate+0x7c>
4000a4a4: b4 10 00 1d mov %i5, %i2
4000a4a8: 10 80 00 06 b 4000a4c0 <_Heap_Greedy_allocate+0xc8>
4000a4ac: 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 ) );
4000a4b0: 92 06 e0 08 add %i3, 8, %o1
4000a4b4: 90 10 00 1c mov %i4, %o0
4000a4b8: 40 00 1f a3 call 40012344 <_Heap_Free>
4000a4bc: b6 10 00 1a mov %i2, %i3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
4000a4c0: 80 a6 e0 00 cmp %i3, 0
4000a4c4: 32 bf ff fb bne,a 4000a4b0 <_Heap_Greedy_allocate+0xb8>
4000a4c8: 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;
}
4000a4cc: 81 c7 e0 08 ret
4000a4d0: 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;
4000a4d4: 10 bf ff e2 b 4000a45c <_Heap_Greedy_allocate+0x64>
4000a4d8: b6 10 20 00 clr %i3
4000a4dc <_Heap_Greedy_free>:
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
4000a4dc: 9d e3 bf a0 save %sp, -96, %sp
while ( blocks != NULL ) {
4000a4e0: 80 a6 60 00 cmp %i1, 0
4000a4e4: 02 80 00 09 be 4000a508 <_Heap_Greedy_free+0x2c> <== NEVER TAKEN
4000a4e8: 01 00 00 00 nop
Heap_Block *current = blocks;
blocks = blocks->next;
4000a4ec: fa 06 60 08 ld [ %i1 + 8 ], %i5
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
4000a4f0: 92 06 60 08 add %i1, 8, %o1
4000a4f4: 40 00 1f 94 call 40012344 <_Heap_Free>
4000a4f8: 90 10 00 18 mov %i0, %o0
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
while ( blocks != NULL ) {
4000a4fc: b2 97 60 00 orcc %i5, 0, %i1
4000a500: 32 bf ff fc bne,a 4000a4f0 <_Heap_Greedy_free+0x14>
4000a504: fa 06 60 08 ld [ %i1 + 8 ], %i5
4000a508: 81 c7 e0 08 ret
4000a50c: 81 e8 00 00 restore
40013420 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40013420: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
Heap_Block *current = heap->first_block;
40013424: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
Heap_Block *end = heap->last_block;
40013428: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
bool stop = false;
while ( !stop && current != end ) {
4001342c: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
40013430: 32 80 00 08 bne,a 40013450 <_Heap_Iterate+0x30> <== NOT EXECUTED
40013434: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40013438: 30 80 00 10 b,a 40013478 <_Heap_Iterate+0x58> <== NOT EXECUTED
4001343c: 90 1a 20 01 xor %o0, 1, %o0 <== NOT EXECUTED
40013440: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013444: 02 80 00 0d be 40013478 <_Heap_Iterate+0x58> <== NOT EXECUTED
40013448: 01 00 00 00 nop <== NOT EXECUTED
4001344c: 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 );
40013450: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
40013454: 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);
40013458: 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;
4001345c: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
40013460: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40013464: 9f c6 40 00 call %i1 <== NOT EXECUTED
40013468: 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 ) {
4001346c: 80 a7 00 1d cmp %i4, %i5 <== NOT EXECUTED
40013470: 12 bf ff f3 bne 4001343c <_Heap_Iterate+0x1c> <== NOT EXECUTED
40013474: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
40013478: 81 c7 e0 08 ret <== NOT EXECUTED
4001347c: 81 e8 00 00 restore <== NOT EXECUTED
4001c10c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
4001c10c: 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);
4001c110: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4001c114: 7f ff f2 84 call 40018b24 <.urem>
4001c118: 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
4001c11c: 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);
4001c120: 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);
4001c124: 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;
4001c128: 80 a2 00 01 cmp %o0, %g1
4001c12c: 0a 80 00 16 bcs 4001c184 <_Heap_Size_of_alloc_area+0x78>
4001c130: 84 10 20 00 clr %g2
4001c134: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
4001c138: 80 a2 00 03 cmp %o0, %g3
4001c13c: 18 80 00 13 bgu 4001c188 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001c140: 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;
4001c144: c8 02 20 04 ld [ %o0 + 4 ], %g4
4001c148: 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);
4001c14c: 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;
4001c150: 80 a0 40 08 cmp %g1, %o0
4001c154: 18 80 00 0d bgu 4001c188 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001c158: 01 00 00 00 nop
4001c15c: 80 a0 c0 08 cmp %g3, %o0
4001c160: 0a 80 00 0a bcs 4001c188 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001c164: 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;
4001c168: 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 )
4001c16c: 80 88 60 01 btst 1, %g1
4001c170: 02 80 00 06 be 4001c188 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001c174: 90 22 00 19 sub %o0, %i1, %o0
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
4001c178: 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;
4001c17c: 90 02 20 04 add %o0, 4, %o0
4001c180: d0 26 80 00 st %o0, [ %i2 ]
4001c184: b0 08 a0 ff and %g2, 0xff, %i0
4001c188: 81 c7 e0 08 ret
4001c18c: 81 e8 00 00 restore
40009274 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
40009274: 9d e3 bf 80 save %sp, -128, %sp
uintptr_t const page_size = heap->page_size;
40009278: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
uintptr_t const min_block_size = heap->min_block_size;
4000927c: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
Heap_Block *const first_block = heap->first_block;
40009280: 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;
40009284: 80 a6 a0 00 cmp %i2, 0
40009288: 02 80 00 0c be 400092b8 <_Heap_Walk+0x44>
4000928c: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40009290: 03 10 00 65 sethi %hi(0x40019400), %g1
40009294: c4 00 60 b8 ld [ %g1 + 0xb8 ], %g2 ! 400194b8 <_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;
40009298: 07 10 00 24 sethi %hi(0x40009000), %g3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
4000929c: 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() ) ) {
400092a0: 80 a0 a0 03 cmp %g2, 3
400092a4: 02 80 00 0c be 400092d4 <_Heap_Walk+0x60> <== ALWAYS TAKEN
400092a8: ae 10 e2 10 or %g3, 0x210, %l7
400092ac: b0 08 60 ff and %g1, 0xff, %i0
400092b0: 81 c7 e0 08 ret
400092b4: 81 e8 00 00 restore
400092b8: 03 10 00 65 sethi %hi(0x40019400), %g1
400092bc: c4 00 60 b8 ld [ %g1 + 0xb8 ], %g2 ! 400194b8 <_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;
400092c0: 07 10 00 24 sethi %hi(0x40009000), %g3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
400092c4: 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() ) ) {
400092c8: 80 a0 a0 03 cmp %g2, 3
400092cc: 12 bf ff f8 bne 400092ac <_Heap_Walk+0x38>
400092d0: ae 10 e2 08 or %g3, 0x208, %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)(
400092d4: da 06 20 18 ld [ %i0 + 0x18 ], %o5
400092d8: c8 06 20 1c ld [ %i0 + 0x1c ], %g4
400092dc: c4 06 20 08 ld [ %i0 + 8 ], %g2
400092e0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400092e4: 90 10 00 19 mov %i1, %o0
400092e8: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
400092ec: f8 23 a0 60 st %i4, [ %sp + 0x60 ]
400092f0: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
400092f4: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
400092f8: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
400092fc: 92 10 20 00 clr %o1
40009300: 96 10 00 1b mov %i3, %o3
40009304: 15 10 00 59 sethi %hi(0x40016400), %o2
40009308: 98 10 00 10 mov %l0, %o4
4000930c: 9f c5 c0 00 call %l7
40009310: 94 12 a2 78 or %o2, 0x278, %o2
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
40009314: 80 a6 e0 00 cmp %i3, 0
40009318: 02 80 00 2a be 400093c0 <_Heap_Walk+0x14c>
4000931c: 80 8e e0 07 btst 7, %i3
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
40009320: 12 80 00 2f bne 400093dc <_Heap_Walk+0x168>
40009324: 90 10 00 10 mov %l0, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40009328: 7f ff e2 12 call 40001b70 <.urem>
4000932c: 92 10 00 1b mov %i3, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
40009330: 80 a2 20 00 cmp %o0, 0
40009334: 12 80 00 32 bne 400093fc <_Heap_Walk+0x188>
40009338: 90 07 20 08 add %i4, 8, %o0
4000933c: 7f ff e2 0d call 40001b70 <.urem>
40009340: 92 10 00 1b mov %i3, %o1
);
return false;
}
if (
40009344: 80 a2 20 00 cmp %o0, 0
40009348: 32 80 00 35 bne,a 4000941c <_Heap_Walk+0x1a8>
4000934c: 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;
40009350: ec 07 20 04 ld [ %i4 + 4 ], %l6
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
40009354: b4 8d a0 01 andcc %l6, 1, %i2
40009358: 22 80 00 38 be,a 40009438 <_Heap_Walk+0x1c4>
4000935c: 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;
40009360: c2 04 60 04 ld [ %l1 + 4 ], %g1
40009364: 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);
40009368: 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;
4000936c: fa 00 60 04 ld [ %g1 + 4 ], %i5
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
40009370: 80 8f 60 01 btst 1, %i5
40009374: 02 80 00 0c be 400093a4 <_Heap_Walk+0x130>
40009378: 80 a7 00 01 cmp %i4, %g1
);
return false;
}
if (
4000937c: 02 80 00 35 be 40009450 <_Heap_Walk+0x1dc>
40009380: 90 10 00 19 mov %i1, %o0
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
40009384: 92 10 20 01 mov 1, %o1
40009388: 15 10 00 59 sethi %hi(0x40016400), %o2
4000938c: 9f c5 c0 00 call %l7
40009390: 94 12 a3 f0 or %o2, 0x3f0, %o2 ! 400167f0 <__log2table+0x2d8>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009394: 82 10 20 00 clr %g1
40009398: b0 08 60 ff and %g1, 0xff, %i0
4000939c: 81 c7 e0 08 ret
400093a0: 81 e8 00 00 restore
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
400093a4: 90 10 00 19 mov %i1, %o0
400093a8: 92 10 20 01 mov 1, %o1
400093ac: 15 10 00 59 sethi %hi(0x40016400), %o2
400093b0: 9f c5 c0 00 call %l7
400093b4: 94 12 a3 d8 or %o2, 0x3d8, %o2 ! 400167d8 <__log2table+0x2c0>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
400093b8: 10 bf ff f8 b 40009398 <_Heap_Walk+0x124>
400093bc: 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" );
400093c0: 90 10 00 19 mov %i1, %o0
400093c4: 92 10 20 01 mov 1, %o1
400093c8: 15 10 00 59 sethi %hi(0x40016400), %o2
400093cc: 9f c5 c0 00 call %l7
400093d0: 94 12 a3 10 or %o2, 0x310, %o2 ! 40016710 <__log2table+0x1f8>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
400093d4: 10 bf ff f1 b 40009398 <_Heap_Walk+0x124>
400093d8: 82 10 20 00 clr %g1
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
400093dc: 90 10 00 19 mov %i1, %o0
400093e0: 92 10 20 01 mov 1, %o1
400093e4: 15 10 00 59 sethi %hi(0x40016400), %o2
400093e8: 96 10 00 1b mov %i3, %o3
400093ec: 9f c5 c0 00 call %l7
400093f0: 94 12 a3 28 or %o2, 0x328, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
400093f4: 10 bf ff e9 b 40009398 <_Heap_Walk+0x124>
400093f8: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
400093fc: 90 10 00 19 mov %i1, %o0
40009400: 92 10 20 01 mov 1, %o1
40009404: 15 10 00 59 sethi %hi(0x40016400), %o2
40009408: 96 10 00 10 mov %l0, %o3
4000940c: 9f c5 c0 00 call %l7
40009410: 94 12 a3 48 or %o2, 0x348, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009414: 10 bf ff e1 b 40009398 <_Heap_Walk+0x124>
40009418: 82 10 20 00 clr %g1
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
4000941c: 92 10 20 01 mov 1, %o1
40009420: 15 10 00 59 sethi %hi(0x40016400), %o2
40009424: 96 10 00 1c mov %i4, %o3
40009428: 9f c5 c0 00 call %l7
4000942c: 94 12 a3 70 or %o2, 0x370, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009430: 10 bf ff da b 40009398 <_Heap_Walk+0x124>
40009434: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
40009438: 92 10 20 01 mov 1, %o1
4000943c: 15 10 00 59 sethi %hi(0x40016400), %o2
40009440: 9f c5 c0 00 call %l7
40009444: 94 12 a3 a8 or %o2, 0x3a8, %o2 ! 400167a8 <__log2table+0x290>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009448: 10 bf ff d4 b 40009398 <_Heap_Walk+0x124>
4000944c: 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;
40009450: 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;
40009454: 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 ) {
40009458: 80 a6 00 1d cmp %i0, %i5
4000945c: 02 80 00 0d be 40009490 <_Heap_Walk+0x21c>
40009460: 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;
40009464: 80 a3 40 1d cmp %o5, %i5
40009468: 28 80 00 bf bleu,a 40009764 <_Heap_Walk+0x4f0> <== ALWAYS TAKEN
4000946c: e6 06 20 24 ld [ %i0 + 0x24 ], %l3
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
40009470: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40009474: 92 10 20 01 mov 1, %o1
40009478: 15 10 00 5a sethi %hi(0x40016800), %o2
4000947c: 96 10 00 1d mov %i5, %o3
40009480: 9f c5 c0 00 call %l7
40009484: 94 12 a0 20 or %o2, 0x20, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009488: 10 bf ff c4 b 40009398 <_Heap_Walk+0x124>
4000948c: 82 10 20 00 clr %g1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
40009490: 27 10 00 5a sethi %hi(0x40016800), %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)(
40009494: 25 10 00 5a sethi %hi(0x40016800), %l2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
40009498: aa 10 00 1c mov %i4, %l5
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4000949c: a6 14 e2 50 or %l3, 0x250, %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)(
400094a0: a4 14 a2 38 or %l2, 0x238, %l2
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
400094a4: 29 10 00 5a sethi %hi(0x40016800), %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;
400094a8: 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);
400094ac: 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;
400094b0: 80 a3 40 1d cmp %o5, %i5
400094b4: 28 80 00 0b bleu,a 400094e0 <_Heap_Walk+0x26c> <== ALWAYS TAKEN
400094b8: 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)(
400094bc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400094c0: 92 10 20 01 mov 1, %o1
400094c4: 96 10 00 15 mov %l5, %o3
400094c8: 15 10 00 5a sethi %hi(0x40016800), %o2
400094cc: 98 10 00 1d mov %i5, %o4
400094d0: 9f c5 c0 00 call %l7
400094d4: 94 12 a0 c8 or %o2, 0xc8, %o2
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
400094d8: 10 bf ff 75 b 400092ac <_Heap_Walk+0x38>
400094dc: 82 10 20 00 clr %g1
400094e0: 80 a3 c0 1d cmp %o7, %i5
400094e4: 0a bf ff f7 bcs 400094c0 <_Heap_Walk+0x24c>
400094e8: 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;
400094ec: 9e 1d 40 11 xor %l5, %l1, %o7
400094f0: 80 a0 00 0f cmp %g0, %o7
400094f4: 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;
400094f8: 90 10 00 16 mov %l6, %o0
400094fc: da 27 bf fc st %o5, [ %fp + -4 ]
40009500: 7f ff e1 9c call 40001b70 <.urem>
40009504: 92 10 00 1b mov %i3, %o1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40009508: 80 a2 20 00 cmp %o0, 0
4000950c: 02 80 00 18 be 4000956c <_Heap_Walk+0x2f8>
40009510: da 07 bf fc ld [ %fp + -4 ], %o5
40009514: 80 8b 60 ff btst 0xff, %o5
40009518: 12 80 00 8b bne 40009744 <_Heap_Walk+0x4d0>
4000951c: 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;
40009520: de 07 60 04 ld [ %i5 + 4 ], %o7
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
40009524: 80 8b e0 01 btst 1, %o7
40009528: 02 80 00 2b be 400095d4 <_Heap_Walk+0x360>
4000952c: 80 a6 a0 00 cmp %i2, 0
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
40009530: 22 80 00 21 be,a 400095b4 <_Heap_Walk+0x340>
40009534: da 05 40 00 ld [ %l5 ], %o5
(*printer)(
40009538: 90 10 00 19 mov %i1, %o0
4000953c: 92 10 20 00 clr %o1
40009540: 94 10 00 12 mov %l2, %o2
40009544: 96 10 00 15 mov %l5, %o3
40009548: 9f c5 c0 00 call %l7
4000954c: 98 10 00 16 mov %l6, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
40009550: 80 a7 00 1d cmp %i4, %i5
40009554: 02 80 00 51 be 40009698 <_Heap_Walk+0x424>
40009558: aa 10 00 1d mov %i5, %l5
4000955c: ec 07 60 04 ld [ %i5 + 4 ], %l6
40009560: da 06 20 20 ld [ %i0 + 0x20 ], %o5
40009564: 10 bf ff d1 b 400094a8 <_Heap_Walk+0x234>
40009568: b4 0d a0 01 and %l6, 1, %i2
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
4000956c: 80 a5 80 10 cmp %l6, %l0
40009570: 0a 80 00 69 bcs 40009714 <_Heap_Walk+0x4a0>
40009574: 80 8b 60 ff btst 0xff, %o5
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
40009578: 80 a5 40 1d cmp %l5, %i5
4000957c: 2a bf ff ea bcs,a 40009524 <_Heap_Walk+0x2b0>
40009580: de 07 60 04 ld [ %i5 + 4 ], %o7
40009584: 80 8b 60 ff btst 0xff, %o5
40009588: 22 bf ff e7 be,a 40009524 <_Heap_Walk+0x2b0>
4000958c: de 07 60 04 ld [ %i5 + 4 ], %o7
(*printer)(
40009590: 90 10 00 19 mov %i1, %o0
40009594: 92 10 20 01 mov 1, %o1
40009598: 96 10 00 15 mov %l5, %o3
4000959c: 15 10 00 5a sethi %hi(0x40016800), %o2
400095a0: 98 10 00 1d mov %i5, %o4
400095a4: 9f c5 c0 00 call %l7
400095a8: 94 12 a1 58 or %o2, 0x158, %o2
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
400095ac: 10 bf ff 40 b 400092ac <_Heap_Walk+0x38>
400095b0: 82 10 20 00 clr %g1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
400095b4: 96 10 00 15 mov %l5, %o3
400095b8: 90 10 00 19 mov %i1, %o0
400095bc: 92 10 20 00 clr %o1
400095c0: 94 10 00 13 mov %l3, %o2
400095c4: 9f c5 c0 00 call %l7
400095c8: 98 10 00 16 mov %l6, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
400095cc: 10 bf ff e2 b 40009554 <_Heap_Walk+0x2e0>
400095d0: 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 ?
400095d4: 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)(
400095d8: de 06 20 08 ld [ %i0 + 8 ], %o7
400095dc: 80 a3 c0 0d cmp %o7, %o5
400095e0: 02 80 00 3d be 400096d4 <_Heap_Walk+0x460>
400095e4: 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)" : ""),
400095e8: 80 a6 00 0d cmp %i0, %o5
400095ec: 02 80 00 40 be 400096ec <_Heap_Walk+0x478>
400095f0: 96 15 22 00 or %l4, 0x200, %o3
block->next,
block->next == last_free_block ?
400095f4: 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)(
400095f8: 80 a3 00 0f cmp %o4, %o7
400095fc: 02 80 00 33 be 400096c8 <_Heap_Walk+0x454>
40009600: 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)" : "")
40009604: 02 80 00 37 be 400096e0 <_Heap_Walk+0x46c>
40009608: 98 15 22 00 or %l4, 0x200, %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)(
4000960c: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
40009610: d8 23 a0 64 st %o4, [ %sp + 0x64 ]
40009614: de 23 a0 60 st %o7, [ %sp + 0x60 ]
40009618: 90 10 00 19 mov %i1, %o0
4000961c: 92 10 20 00 clr %o1
40009620: 15 10 00 5a sethi %hi(0x40016800), %o2
40009624: 96 10 00 15 mov %l5, %o3
40009628: 94 12 a1 90 or %o2, 0x190, %o2
4000962c: 9f c5 c0 00 call %l7
40009630: 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 ) {
40009634: da 07 40 00 ld [ %i5 ], %o5
40009638: 80 a5 80 0d cmp %l6, %o5
4000963c: 12 80 00 19 bne 400096a0 <_Heap_Walk+0x42c>
40009640: 80 a6 a0 00 cmp %i2, 0
);
return false;
}
if ( !prev_used ) {
40009644: 02 80 00 2d be 400096f8 <_Heap_Walk+0x484>
40009648: 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;
4000964c: 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 ) {
40009650: 80 a6 00 02 cmp %i0, %g2
40009654: 02 80 00 0b be 40009680 <_Heap_Walk+0x40c> <== NEVER TAKEN
40009658: 92 10 20 01 mov 1, %o1
if ( free_block == block ) {
4000965c: 80 a5 40 02 cmp %l5, %g2
40009660: 02 bf ff bd be 40009554 <_Heap_Walk+0x2e0>
40009664: 80 a7 00 1d cmp %i4, %i5
return true;
}
free_block = free_block->next;
40009668: 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 ) {
4000966c: 80 a6 00 02 cmp %i0, %g2
40009670: 12 bf ff fc bne 40009660 <_Heap_Walk+0x3ec>
40009674: 80 a5 40 02 cmp %l5, %g2
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
40009678: 90 10 00 19 mov %i1, %o0
4000967c: 92 10 20 01 mov 1, %o1
40009680: 15 10 00 5a sethi %hi(0x40016800), %o2
40009684: 96 10 00 15 mov %l5, %o3
40009688: 9f c5 c0 00 call %l7
4000968c: 94 12 a2 78 or %o2, 0x278, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009690: 10 bf ff 42 b 40009398 <_Heap_Walk+0x124>
40009694: 82 10 20 00 clr %g1
}
block = next_block;
} while ( block != first_block );
return true;
40009698: 10 bf ff 05 b 400092ac <_Heap_Walk+0x38>
4000969c: 82 10 20 01 mov 1, %g1
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
400096a0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
400096a4: 90 10 00 19 mov %i1, %o0
400096a8: 92 10 20 01 mov 1, %o1
400096ac: 15 10 00 5a sethi %hi(0x40016800), %o2
400096b0: 96 10 00 15 mov %l5, %o3
400096b4: 94 12 a1 c8 or %o2, 0x1c8, %o2
400096b8: 9f c5 c0 00 call %l7
400096bc: 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;
400096c0: 10 bf ff 36 b 40009398 <_Heap_Walk+0x124>
400096c4: 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)(
400096c8: 03 10 00 59 sethi %hi(0x40016400), %g1
400096cc: 10 bf ff d0 b 4000960c <_Heap_Walk+0x398>
400096d0: 98 10 62 58 or %g1, 0x258, %o4 ! 40016658 <__log2table+0x140>
400096d4: 03 10 00 59 sethi %hi(0x40016400), %g1
400096d8: 10 bf ff c7 b 400095f4 <_Heap_Walk+0x380>
400096dc: 96 10 62 38 or %g1, 0x238, %o3 ! 40016638 <__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)" : "")
400096e0: 03 10 00 59 sethi %hi(0x40016400), %g1
400096e4: 10 bf ff ca b 4000960c <_Heap_Walk+0x398>
400096e8: 98 10 62 68 or %g1, 0x268, %o4 ! 40016668 <__log2table+0x150>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
400096ec: 17 10 00 59 sethi %hi(0x40016400), %o3
400096f0: 10 bf ff c1 b 400095f4 <_Heap_Walk+0x380>
400096f4: 96 12 e2 48 or %o3, 0x248, %o3 ! 40016648 <__log2table+0x130>
return false;
}
if ( !prev_used ) {
(*printer)(
400096f8: 92 10 20 01 mov 1, %o1
400096fc: 15 10 00 5a sethi %hi(0x40016800), %o2
40009700: 96 10 00 15 mov %l5, %o3
40009704: 9f c5 c0 00 call %l7
40009708: 94 12 a2 08 or %o2, 0x208, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000970c: 10 bf ff 23 b 40009398 <_Heap_Walk+0x124>
40009710: 82 10 20 00 clr %g1
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
40009714: 02 bf ff 9a be 4000957c <_Heap_Walk+0x308> <== NEVER TAKEN
40009718: 80 a5 40 1d cmp %l5, %i5
(*printer)(
4000971c: 90 10 00 19 mov %i1, %o0
40009720: 92 10 20 01 mov 1, %o1
40009724: 96 10 00 15 mov %l5, %o3
40009728: 15 10 00 5a sethi %hi(0x40016800), %o2
4000972c: 98 10 00 16 mov %l6, %o4
40009730: 94 12 a1 28 or %o2, 0x128, %o2
40009734: 9f c5 c0 00 call %l7
40009738: 9a 10 00 10 mov %l0, %o5
block,
block_size,
min_block_size
);
return false;
4000973c: 10 bf fe dc b 400092ac <_Heap_Walk+0x38>
40009740: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
40009744: 92 10 20 01 mov 1, %o1
40009748: 96 10 00 15 mov %l5, %o3
4000974c: 15 10 00 5a sethi %hi(0x40016800), %o2
40009750: 98 10 00 16 mov %l6, %o4
40009754: 9f c5 c0 00 call %l7
40009758: 94 12 a0 f8 or %o2, 0xf8, %o2
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
4000975c: 10 bf fe d4 b 400092ac <_Heap_Walk+0x38>
40009760: 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;
40009764: 80 a4 c0 1d cmp %l3, %i5
40009768: 0a bf ff 43 bcs 40009474 <_Heap_Walk+0x200> <== NEVER TAKEN
4000976c: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
40009770: da 27 bf fc st %o5, [ %fp + -4 ]
40009774: 90 07 60 08 add %i5, 8, %o0
40009778: 7f ff e0 fe call 40001b70 <.urem>
4000977c: 92 10 00 14 mov %l4, %o1
);
return false;
}
if (
40009780: 80 a2 20 00 cmp %o0, 0
40009784: 12 80 00 36 bne 4000985c <_Heap_Walk+0x5e8> <== NEVER TAKEN
40009788: 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;
4000978c: c2 07 60 04 ld [ %i5 + 4 ], %g1
40009790: 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;
40009794: 82 07 40 01 add %i5, %g1, %g1
40009798: c2 00 60 04 ld [ %g1 + 4 ], %g1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
4000979c: 80 88 60 01 btst 1, %g1
400097a0: 12 80 00 27 bne 4000983c <_Heap_Walk+0x5c8> <== NEVER TAKEN
400097a4: a4 10 00 1d mov %i5, %l2
400097a8: 10 80 00 19 b 4000980c <_Heap_Walk+0x598>
400097ac: 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 ) {
400097b0: 80 a6 00 1d cmp %i0, %i5
400097b4: 02 bf ff 37 be 40009490 <_Heap_Walk+0x21c>
400097b8: 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;
400097bc: 0a bf ff 2e bcs 40009474 <_Heap_Walk+0x200>
400097c0: 90 10 00 19 mov %i1, %o0
400097c4: 80 a7 40 13 cmp %i5, %l3
400097c8: 18 bf ff 2c bgu 40009478 <_Heap_Walk+0x204> <== NEVER TAKEN
400097cc: 92 10 20 01 mov 1, %o1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
400097d0: da 27 bf fc st %o5, [ %fp + -4 ]
400097d4: 90 07 60 08 add %i5, 8, %o0
400097d8: 7f ff e0 e6 call 40001b70 <.urem>
400097dc: 92 10 00 14 mov %l4, %o1
);
return false;
}
if (
400097e0: 80 a2 20 00 cmp %o0, 0
400097e4: 12 80 00 1e bne 4000985c <_Heap_Walk+0x5e8>
400097e8: 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;
400097ec: de 07 60 04 ld [ %i5 + 4 ], %o7
400097f0: 82 10 00 12 mov %l2, %g1
400097f4: 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;
400097f8: 9e 03 c0 1d add %o7, %i5, %o7
400097fc: de 03 e0 04 ld [ %o7 + 4 ], %o7
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
40009800: 80 8b e0 01 btst 1, %o7
40009804: 12 80 00 0e bne 4000983c <_Heap_Walk+0x5c8>
40009808: a4 10 00 1d mov %i5, %l2
);
return false;
}
if ( free_block->prev != prev_block ) {
4000980c: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40009810: 80 a3 00 01 cmp %o4, %g1
40009814: 22 bf ff e7 be,a 400097b0 <_Heap_Walk+0x53c>
40009818: fa 07 60 08 ld [ %i5 + 8 ], %i5
(*printer)(
4000981c: 90 10 00 19 mov %i1, %o0
40009820: 92 10 20 01 mov 1, %o1
40009824: 15 10 00 5a sethi %hi(0x40016800), %o2
40009828: 96 10 00 1d mov %i5, %o3
4000982c: 9f c5 c0 00 call %l7
40009830: 94 12 a0 90 or %o2, 0x90, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009834: 10 bf fe d9 b 40009398 <_Heap_Walk+0x124>
40009838: 82 10 20 00 clr %g1
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
4000983c: 90 10 00 19 mov %i1, %o0
40009840: 92 10 20 01 mov 1, %o1
40009844: 15 10 00 5a sethi %hi(0x40016800), %o2
40009848: 96 10 00 1d mov %i5, %o3
4000984c: 9f c5 c0 00 call %l7
40009850: 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;
40009854: 10 bf fe d1 b 40009398 <_Heap_Walk+0x124>
40009858: 82 10 20 00 clr %g1
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
4000985c: 90 10 00 19 mov %i1, %o0
40009860: 92 10 20 01 mov 1, %o1
40009864: 15 10 00 5a sethi %hi(0x40016800), %o2
40009868: 96 10 00 1d mov %i5, %o3
4000986c: 9f c5 c0 00 call %l7
40009870: 94 12 a0 40 or %o2, 0x40, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
40009874: 10 bf fe c9 b 40009398 <_Heap_Walk+0x124>
40009878: 82 10 20 00 clr %g1
40007c14 <_IO_Initialize_all_drivers>:
_IO_Driver_address_table[index] = driver_table[index];
}
void _IO_Initialize_all_drivers( void )
{
40007c14: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007c18: 39 10 00 7e sethi %hi(0x4001f800), %i4
40007c1c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1 ! 4001f818 <_IO_Number_of_drivers>
40007c20: ba 10 20 00 clr %i5
40007c24: 80 a0 60 00 cmp %g1, 0
40007c28: 02 80 00 0b be 40007c54 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
40007c2c: b8 17 20 18 or %i4, 0x18, %i4
(void) rtems_io_initialize( major, 0, NULL );
40007c30: 90 10 00 1d mov %i5, %o0
40007c34: 92 10 20 00 clr %o1
40007c38: 40 00 15 91 call 4000d27c <rtems_io_initialize>
40007c3c: 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 ++ )
40007c40: c2 07 00 00 ld [ %i4 ], %g1
40007c44: ba 07 60 01 inc %i5
40007c48: 80 a0 40 1d cmp %g1, %i5
40007c4c: 18 bf ff fa bgu 40007c34 <_IO_Initialize_all_drivers+0x20>
40007c50: 90 10 00 1d mov %i5, %o0
40007c54: 81 c7 e0 08 ret
40007c58: 81 e8 00 00 restore
40007b44 <_IO_Manager_initialization>:
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
{
40007b44: 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();
40007b48: 03 10 00 71 sethi %hi(0x4001c400), %g1
40007b4c: 82 10 60 18 or %g1, 0x18, %g1 ! 4001c418 <Configuration>
drivers_in_table = rtems_configuration_get_number_of_device_drivers();
40007b50: f8 00 60 38 ld [ %g1 + 0x38 ], %i4
number_of_drivers = rtems_configuration_get_maximum_drivers();
40007b54: 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 )
40007b58: 80 a7 00 1b cmp %i4, %i3
40007b5c: 0a 80 00 08 bcs 40007b7c <_IO_Manager_initialization+0x38>
40007b60: 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;
40007b64: 03 10 00 7e sethi %hi(0x4001f800), %g1
40007b68: fa 20 60 1c st %i5, [ %g1 + 0x1c ] ! 4001f81c <_IO_Driver_address_table>
_IO_Number_of_drivers = number_of_drivers;
40007b6c: 03 10 00 7e sethi %hi(0x4001f800), %g1
40007b70: f8 20 60 18 st %i4, [ %g1 + 0x18 ] ! 4001f818 <_IO_Number_of_drivers>
return;
40007b74: 81 c7 e0 08 ret
40007b78: 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 )
40007b7c: 83 2e e0 03 sll %i3, 3, %g1
40007b80: b5 2e e0 05 sll %i3, 5, %i2
40007b84: 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(
40007b88: 40 00 0d 2f call 4000b044 <_Workspace_Allocate_or_fatal_error>
40007b8c: 90 10 00 1a mov %i2, %o0
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
40007b90: 03 10 00 7e sethi %hi(0x4001f800), %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 *)
40007b94: 33 10 00 7e sethi %hi(0x4001f800), %i1
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
40007b98: f6 20 60 18 st %i3, [ %g1 + 0x18 ]
/*
* 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 *)
40007b9c: d0 26 60 1c st %o0, [ %i1 + 0x1c ]
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
40007ba0: 92 10 20 00 clr %o1
40007ba4: 40 00 21 75 call 40010178 <memset>
40007ba8: 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++ )
40007bac: 80 a7 20 00 cmp %i4, 0
40007bb0: 02 bf ff f1 be 40007b74 <_IO_Manager_initialization+0x30> <== NEVER TAKEN
40007bb4: c8 06 60 1c ld [ %i1 + 0x1c ], %g4
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
40007bb8: 85 2f 20 03 sll %i4, 3, %g2
40007bbc: b7 2f 20 05 sll %i4, 5, %i3
40007bc0: 82 10 20 00 clr %g1
40007bc4: 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];
40007bc8: c4 07 40 01 ld [ %i5 + %g1 ], %g2
40007bcc: 86 07 40 01 add %i5, %g1, %g3
40007bd0: c4 21 00 01 st %g2, [ %g4 + %g1 ]
40007bd4: f8 00 e0 04 ld [ %g3 + 4 ], %i4
40007bd8: 84 01 00 01 add %g4, %g1, %g2
40007bdc: f8 20 a0 04 st %i4, [ %g2 + 4 ]
40007be0: f8 00 e0 08 ld [ %g3 + 8 ], %i4
40007be4: 82 00 60 18 add %g1, 0x18, %g1
40007be8: f8 20 a0 08 st %i4, [ %g2 + 8 ]
40007bec: 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++ )
40007bf0: 80 a0 40 1b cmp %g1, %i3
_IO_Driver_address_table[index] = driver_table[index];
40007bf4: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
40007bf8: f8 00 e0 10 ld [ %g3 + 0x10 ], %i4
40007bfc: f8 20 a0 10 st %i4, [ %g2 + 0x10 ]
40007c00: 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++ )
40007c04: 12 bf ff f1 bne 40007bc8 <_IO_Manager_initialization+0x84>
40007c08: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
40007c0c: 81 c7 e0 08 ret
40007c10: 81 e8 00 00 restore
4000890c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
4000890c: 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 );
40008910: 13 10 00 2a sethi %hi(0x4000a800), %o1
40008914: 90 07 bf f4 add %fp, -12, %o0
40008918: 92 12 62 7c or %o1, 0x27c, %o1
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
4000891c: f0 27 bf f4 st %i0, [ %fp + -12 ]
40008920: f2 2f bf f8 stb %i1, [ %fp + -8 ]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
40008924: 40 00 08 61 call 4000aaa8 <_User_extensions_Iterate>
40008928: 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;
4000892c: 05 10 00 7c sethi %hi(0x4001f000), %g2 <== NOT EXECUTED
40008930: 82 10 a3 bc or %g2, 0x3bc, %g1 ! 4001f3bc <_Internal_errors_What_happened><== NOT EXECUTED
40008934: f0 20 a3 bc st %i0, [ %g2 + 0x3bc ] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
40008938: f2 28 60 04 stb %i1, [ %g1 + 4 ] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
4000893c: 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;
40008940: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
40008944: 03 10 00 7c sethi %hi(0x4001f000), %g1 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
40008948: 7f ff e5 d7 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
4000894c: c4 20 63 c8 st %g2, [ %g1 + 0x3c8 ] ! 4001f3c8 <_System_state_Current><== NOT EXECUTED
40008950: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
40008954: 30 80 00 00 b,a 40008954 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
400089c4 <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
400089c4: 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 )
400089c8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400089cc: 80 a0 60 00 cmp %g1, 0
400089d0: 02 80 00 26 be 40008a68 <_Objects_Allocate+0xa4> <== NEVER TAKEN
400089d4: 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 );
400089d8: b8 06 20 20 add %i0, 0x20, %i4
400089dc: 7f ff fd 4c call 40007f0c <_Chain_Get>
400089e0: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
400089e4: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
400089e8: 80 a0 60 00 cmp %g1, 0
400089ec: 02 80 00 16 be 40008a44 <_Objects_Allocate+0x80>
400089f0: 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 ) {
400089f4: 80 a2 20 00 cmp %o0, 0
400089f8: 02 80 00 15 be 40008a4c <_Objects_Allocate+0x88>
400089fc: 01 00 00 00 nop
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40008a00: c4 07 60 08 ld [ %i5 + 8 ], %g2
40008a04: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
40008a08: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40008a0c: 03 00 00 3f sethi %hi(0xfc00), %g1
40008a10: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40008a14: 90 0a 00 01 and %o0, %g1, %o0
40008a18: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
40008a1c: 40 00 3f 96 call 40018874 <.udiv>
40008a20: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
40008a24: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40008a28: 91 2a 20 02 sll %o0, 2, %o0
40008a2c: c6 00 40 08 ld [ %g1 + %o0 ], %g3
information->inactive--;
40008a30: 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 ]--;
40008a34: 86 00 ff ff add %g3, -1, %g3
40008a38: c6 20 40 08 st %g3, [ %g1 + %o0 ]
information->inactive--;
40008a3c: 82 00 bf ff add %g2, -1, %g1
40008a40: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
40008a44: 81 c7 e0 08 ret
40008a48: 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 );
40008a4c: 40 00 00 10 call 40008a8c <_Objects_Extend_information>
40008a50: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
40008a54: 7f ff fd 2e call 40007f0c <_Chain_Get>
40008a58: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
40008a5c: b0 92 20 00 orcc %o0, 0, %i0
40008a60: 32 bf ff e9 bne,a 40008a04 <_Objects_Allocate+0x40>
40008a64: 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;
40008a68: 81 c7 e0 08 ret
40008a6c: 91 e8 20 00 restore %g0, 0, %o0
40008a8c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
40008a8c: 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 )
40008a90: 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 );
40008a94: e0 16 20 0a lduh [ %i0 + 0xa ], %l0
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
40008a98: 80 a6 60 00 cmp %i1, 0
40008a9c: 02 80 00 a1 be 40008d20 <_Objects_Extend_information+0x294>
40008aa0: e2 16 20 10 lduh [ %i0 + 0x10 ], %l1
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
40008aa4: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3
40008aa8: a3 2c 60 10 sll %l1, 0x10, %l1
40008aac: 92 10 00 1b mov %i3, %o1
40008ab0: 40 00 3f 71 call 40018874 <.udiv>
40008ab4: 91 34 60 10 srl %l1, 0x10, %o0
40008ab8: 91 2a 20 10 sll %o0, 0x10, %o0
40008abc: b5 32 20 10 srl %o0, 0x10, %i2
for ( ; block < block_count; block++ ) {
40008ac0: 80 a6 a0 00 cmp %i2, 0
40008ac4: 02 80 00 af be 40008d80 <_Objects_Extend_information+0x2f4><== NEVER TAKEN
40008ac8: 90 10 00 1b mov %i3, %o0
if ( information->object_blocks[ block ] == NULL ) {
40008acc: c2 06 40 00 ld [ %i1 ], %g1
40008ad0: 80 a0 60 00 cmp %g1, 0
40008ad4: 02 80 00 b1 be 40008d98 <_Objects_Extend_information+0x30c><== NEVER TAKEN
40008ad8: 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;
40008adc: 10 80 00 06 b 40008af4 <_Objects_Extend_information+0x68>
40008ae0: 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 ) {
40008ae4: c2 06 40 01 ld [ %i1 + %g1 ], %g1
40008ae8: 80 a0 60 00 cmp %g1, 0
40008aec: 22 80 00 08 be,a 40008b0c <_Objects_Extend_information+0x80>
40008af0: 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++ ) {
40008af4: ba 07 60 01 inc %i5
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
40008af8: 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++ ) {
40008afc: 80 a6 80 1d cmp %i2, %i5
40008b00: 18 bf ff f9 bgu 40008ae4 <_Objects_Extend_information+0x58>
40008b04: 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;
40008b08: b6 10 20 01 mov 1, %i3
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
40008b0c: 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 ) {
40008b10: 03 00 00 3f sethi %hi(0xfc00), %g1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
40008b14: 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 ) {
40008b18: 82 10 63 ff or %g1, 0x3ff, %g1
40008b1c: 80 a6 40 01 cmp %i1, %g1
40008b20: 18 80 00 9c bgu 40008d90 <_Objects_Extend_information+0x304>
40008b24: 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;
40008b28: 40 00 3f 19 call 4001878c <.umul>
40008b2c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
if ( information->auto_extend ) {
40008b30: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
40008b34: 80 a0 60 00 cmp %g1, 0
40008b38: 02 80 00 6d be 40008cec <_Objects_Extend_information+0x260>
40008b3c: 01 00 00 00 nop
new_object_block = _Workspace_Allocate( block_size );
40008b40: 40 00 09 33 call 4000b00c <_Workspace_Allocate>
40008b44: 01 00 00 00 nop
if ( !new_object_block )
40008b48: a2 92 20 00 orcc %o0, 0, %l1
40008b4c: 02 80 00 91 be 40008d90 <_Objects_Extend_information+0x304>
40008b50: 01 00 00 00 nop
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
40008b54: 80 8e e0 ff btst 0xff, %i3
40008b58: 22 80 00 42 be,a 40008c60 <_Objects_Extend_information+0x1d4>
40008b5c: 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 ) {
40008b60: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
*/
/*
* Up the block count and maximum
*/
block_count++;
40008b64: 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 ) {
40008b68: 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 *)) +
40008b6c: 91 2e e0 01 sll %i3, 1, %o0
40008b70: 90 02 00 1b add %o0, %i3, %o0
((maximum + minimum_index) * sizeof(Objects_Control *));
40008b74: 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 *)) +
40008b78: 90 02 00 10 add %o0, %l0, %o0
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
40008b7c: 12 80 00 60 bne 40008cfc <_Objects_Extend_information+0x270>
40008b80: 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 );
40008b84: 40 00 09 30 call 4000b044 <_Workspace_Allocate_or_fatal_error>
40008b88: 01 00 00 00 nop
40008b8c: 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 ) {
40008b90: 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*) );
40008b94: 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 ) {
40008b98: 80 a4 00 01 cmp %l0, %g1
40008b9c: a6 04 80 1b add %l2, %i3, %l3
40008ba0: 0a 80 00 67 bcs 40008d3c <_Objects_Extend_information+0x2b0>
40008ba4: b6 04 c0 1b add %l3, %i3, %i3
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
40008ba8: 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++ ) {
40008bac: 80 a4 20 00 cmp %l0, 0
40008bb0: 02 80 00 07 be 40008bcc <_Objects_Extend_information+0x140><== NEVER TAKEN
40008bb4: 82 10 20 00 clr %g1
local_table[ index ] = NULL;
40008bb8: c0 20 40 1b clr [ %g1 + %i3 ]
40008bbc: 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++ ) {
40008bc0: 80 a0 40 02 cmp %g1, %g2
40008bc4: 32 bf ff fe bne,a 40008bbc <_Objects_Extend_information+0x130><== NEVER TAKEN
40008bc8: c0 20 40 1b clr [ %g1 + %i3 ] <== NOT EXECUTED
40008bcc: 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 );
40008bd0: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
40008bd4: c0 24 80 1a clr [ %l2 + %i2 ]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
40008bd8: 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 ;
40008bdc: 80 a7 00 01 cmp %i4, %g1
40008be0: 1a 80 00 0b bcc 40008c0c <_Objects_Extend_information+0x180><== NEVER TAKEN
40008be4: c0 24 c0 1a clr [ %l3 + %i2 ]
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
40008be8: 85 2f 20 02 sll %i4, 2, %g2
40008bec: 87 28 e0 02 sll %g3, 2, %g3
40008bf0: 84 06 c0 02 add %i3, %g2, %g2
40008bf4: 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;
40008bf8: c0 20 80 01 clr [ %g2 + %g1 ]
40008bfc: 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 ;
40008c00: 80 a0 40 03 cmp %g1, %g3
40008c04: 32 bf ff fe bne,a 40008bfc <_Objects_Extend_information+0x170>
40008c08: c0 20 80 01 clr [ %g2 + %g1 ]
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
40008c0c: 7f ff e5 26 call 400020a4 <sparc_disable_interrupts>
40008c10: 01 00 00 00 nop
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008c14: 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(
40008c18: c4 16 20 04 lduh [ %i0 + 4 ], %g2
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
40008c1c: 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;
40008c20: f2 36 20 10 sth %i1, [ %i0 + 0x10 ]
40008c24: 87 28 e0 18 sll %g3, 0x18, %g3
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008c28: 85 28 a0 1b sll %g2, 0x1b, %g2
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
40008c2c: e4 26 20 34 st %l2, [ %i0 + 0x34 ]
information->inactive_per_block = inactive_per_block;
40008c30: e6 26 20 30 st %l3, [ %i0 + 0x30 ]
information->local_table = local_table;
40008c34: 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) |
40008c38: 03 00 00 40 sethi %hi(0x10000), %g1
40008c3c: 82 10 c0 01 or %g3, %g1, %g1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008c40: 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) |
40008c44: b2 10 40 19 or %g1, %i1, %i1
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
40008c48: f2 26 20 0c st %i1, [ %i0 + 0xc ]
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
40008c4c: 7f ff e5 1a call 400020b4 <sparc_enable_interrupts>
40008c50: 01 00 00 00 nop
_Workspace_Free( old_tables );
40008c54: 40 00 08 f6 call 4000b02c <_Workspace_Free>
40008c58: 90 10 00 1a mov %i2, %o0
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
40008c5c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40008c60: bb 2f 60 02 sll %i5, 2, %i5
40008c64: e2 20 40 1d st %l1, [ %g1 + %i5 ]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
40008c68: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40008c6c: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2
40008c70: d2 00 40 1d ld [ %g1 + %i5 ], %o1
40008c74: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
40008c78: 90 07 bf f4 add %fp, -12, %o0
40008c7c: 7f ff fc b4 call 40007f4c <_Chain_Initialize>
40008c80: 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 ) {
40008c84: 10 80 00 0d b 40008cb8 <_Objects_Extend_information+0x22c>
40008c88: b6 06 20 20 add %i0, 0x20, %i3
the_object->id = _Objects_Build_id(
40008c8c: c6 16 20 04 lduh [ %i0 + 4 ], %g3
40008c90: 85 28 a0 18 sll %g2, 0x18, %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008c94: 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) |
40008c98: 84 10 80 1a or %g2, %i2, %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008c9c: 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) |
40008ca0: 84 10 80 1c or %g2, %i4, %g2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
40008ca4: 90 10 00 1b mov %i3, %o0
40008ca8: 92 10 00 01 mov %g1, %o1
index++;
40008cac: b8 07 20 01 inc %i4
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
40008cb0: 7f ff fc 8c call 40007ee0 <_Chain_Append>
40008cb4: 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 ) {
40008cb8: 7f ff fc 95 call 40007f0c <_Chain_Get>
40008cbc: 90 07 bf f4 add %fp, -12, %o0
40008cc0: 82 92 20 00 orcc %o0, 0, %g1
40008cc4: 32 bf ff f2 bne,a 40008c8c <_Objects_Extend_information+0x200>
40008cc8: c4 06 00 00 ld [ %i0 ], %g2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
40008ccc: c8 16 20 14 lduh [ %i0 + 0x14 ], %g4
40008cd0: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
40008cd4: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
40008cd8: c8 20 c0 1d st %g4, [ %g3 + %i5 ]
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
40008cdc: 82 00 80 04 add %g2, %g4, %g1
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
40008ce0: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
40008ce4: 81 c7 e0 08 ret
40008ce8: 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 );
40008cec: 40 00 08 d6 call 4000b044 <_Workspace_Allocate_or_fatal_error>
40008cf0: 01 00 00 00 nop
40008cf4: 10 bf ff 98 b 40008b54 <_Objects_Extend_information+0xc8>
40008cf8: 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 );
40008cfc: 40 00 08 c4 call 4000b00c <_Workspace_Allocate>
40008d00: 01 00 00 00 nop
if ( !object_blocks ) {
40008d04: a4 92 20 00 orcc %o0, 0, %l2
40008d08: 32 bf ff a3 bne,a 40008b94 <_Objects_Extend_information+0x108>
40008d0c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
_Workspace_Free( new_object_block );
40008d10: 40 00 08 c7 call 4000b02c <_Workspace_Free>
40008d14: 90 10 00 11 mov %l1, %o0
40008d18: 81 c7 e0 08 ret
40008d1c: 81 e8 00 00 restore
40008d20: 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 );
40008d24: 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;
40008d28: b6 10 20 01 mov 1, %i3
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
40008d2c: ba 10 20 00 clr %i5
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
40008d30: b4 10 20 00 clr %i2
40008d34: 10 bf ff 76 b 40008b0c <_Objects_Extend_information+0x80>
40008d38: 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,
40008d3c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
information->object_blocks,
block_count * sizeof(void*) );
40008d40: 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,
40008d44: 90 10 00 12 mov %l2, %o0
40008d48: 40 00 1c cf call 40010084 <memcpy>
40008d4c: 94 10 00 1a mov %i2, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
40008d50: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
40008d54: 94 10 00 1a mov %i2, %o2
40008d58: 40 00 1c cb call 40010084 <memcpy>
40008d5c: 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 *) );
40008d60: 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,
40008d64: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40008d68: 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,
40008d6c: 90 10 00 1b mov %i3, %o0
40008d70: 40 00 1c c5 call 40010084 <memcpy>
40008d74: 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 );
40008d78: 10 bf ff 97 b 40008bd4 <_Objects_Extend_information+0x148>
40008d7c: 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 );
40008d80: 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;
40008d84: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
40008d88: 10 bf ff 61 b 40008b0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40008d8c: ba 10 20 00 clr %i5 <== NOT EXECUTED
40008d90: 81 c7 e0 08 ret
40008d94: 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;
40008d98: 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;
40008d9c: 10 bf ff 5c b 40008b0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40008da0: ba 10 20 00 clr %i5 <== NOT EXECUTED
40008e54 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
40008e54: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
40008e58: 80 a6 60 00 cmp %i1, 0
40008e5c: 02 80 00 19 be 40008ec0 <_Objects_Get_information+0x6c>
40008e60: 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 );
40008e64: 40 00 12 82 call 4000d86c <_Objects_API_maximum_class>
40008e68: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
40008e6c: 80 a2 20 00 cmp %o0, 0
40008e70: 02 80 00 14 be 40008ec0 <_Objects_Get_information+0x6c>
40008e74: 80 a2 00 19 cmp %o0, %i1
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
40008e78: 0a 80 00 12 bcs 40008ec0 <_Objects_Get_information+0x6c>
40008e7c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
40008e80: b1 2e 20 02 sll %i0, 2, %i0
40008e84: 82 10 62 24 or %g1, 0x224, %g1
40008e88: c2 00 40 18 ld [ %g1 + %i0 ], %g1
40008e8c: 80 a0 60 00 cmp %g1, 0
40008e90: 02 80 00 0c be 40008ec0 <_Objects_Get_information+0x6c> <== NEVER TAKEN
40008e94: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
40008e98: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
40008e9c: 80 a6 20 00 cmp %i0, 0
40008ea0: 02 80 00 08 be 40008ec0 <_Objects_Get_information+0x6c> <== NEVER TAKEN
40008ea4: 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 )
40008ea8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
40008eac: 80 a0 60 00 cmp %g1, 0
40008eb0: 02 80 00 04 be 40008ec0 <_Objects_Get_information+0x6c>
40008eb4: 01 00 00 00 nop
return NULL;
#endif
return info;
}
40008eb8: 81 c7 e0 08 ret
40008ebc: 81 e8 00 00 restore
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
40008ec0: 81 c7 e0 08 ret
40008ec4: 91 e8 20 00 restore %g0, 0, %o0
40017328 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
40017328: 9d e3 bf 90 save %sp, -112, %sp
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
4001732c: 80 a6 60 00 cmp %i1, 0
40017330: 02 80 00 11 be 40017374 <_Objects_Get_name_as_string+0x4c>
40017334: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( name == NULL )
40017338: 02 80 00 0f be 40017374 <_Objects_Get_name_as_string+0x4c>
4001733c: ba 96 20 00 orcc %i0, 0, %i5
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40017340: 02 80 00 3d be 40017434 <_Objects_Get_name_as_string+0x10c>
40017344: 03 10 00 ca sethi %hi(0x40032800), %g1
information = _Objects_Get_information_id( tmpId );
40017348: 7f ff e0 8e call 4000f580 <_Objects_Get_information_id>
4001734c: 90 10 00 1d mov %i5, %o0
if ( !information )
40017350: b8 92 20 00 orcc %o0, 0, %i4
40017354: 02 80 00 08 be 40017374 <_Objects_Get_name_as_string+0x4c>
40017358: 92 10 00 1d mov %i5, %o1
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
4001735c: 7f ff e0 c9 call 4000f680 <_Objects_Get>
40017360: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
40017364: c2 07 bf f4 ld [ %fp + -12 ], %g1
40017368: 80 a0 60 00 cmp %g1, 0
4001736c: 22 80 00 05 be,a 40017380 <_Objects_Get_name_as_string+0x58>
40017370: c2 0f 20 38 ldub [ %i4 + 0x38 ], %g1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
40017374: b4 10 20 00 clr %i2
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
40017378: 81 c7 e0 08 ret
4001737c: 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 ) {
40017380: 80 a0 60 00 cmp %g1, 0
40017384: 12 80 00 2f bne 40017440 <_Objects_Get_name_as_string+0x118>
40017388: 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;
4001738c: 89 30 60 18 srl %g1, 0x18, %g4
lname[ 1 ] = (u32_name >> 16) & 0xff;
40017390: 87 30 60 10 srl %g1, 0x10, %g3
lname[ 2 ] = (u32_name >> 8) & 0xff;
40017394: 85 30 60 08 srl %g1, 8, %g2
lname[ 3 ] = (u32_name >> 0) & 0xff;
40017398: c2 2f bf fb stb %g1, [ %fp + -5 ]
lname[ 4 ] = '\0';
4001739c: 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;
400173a0: c8 2f bf f8 stb %g4, [ %fp + -8 ]
lname[ 1 ] = (u32_name >> 16) & 0xff;
400173a4: c6 2f bf f9 stb %g3, [ %fp + -7 ]
lname[ 2 ] = (u32_name >> 8) & 0xff;
400173a8: c4 2f bf fa stb %g2, [ %fp + -6 ]
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
400173ac: 82 07 bf f8 add %fp, -8, %g1
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
400173b0: 80 a6 60 01 cmp %i1, 1
400173b4: 02 80 00 27 be 40017450 <_Objects_Get_name_as_string+0x128><== NEVER TAKEN
400173b8: 86 10 00 1a mov %i2, %g3
400173bc: c6 48 40 00 ldsb [ %g1 ], %g3
400173c0: 80 a0 e0 00 cmp %g3, 0
400173c4: 02 80 00 22 be 4001744c <_Objects_Get_name_as_string+0x124>
400173c8: 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(
400173cc: b6 06 7f ff add %i1, -1, %i3
400173d0: 39 10 00 c4 sethi %hi(0x40031000), %i4
400173d4: b6 00 40 1b add %g1, %i3, %i3
400173d8: 86 10 00 1a mov %i2, %g3
400173dc: 10 80 00 06 b 400173f4 <_Objects_Get_name_as_string+0xcc>
400173e0: b8 17 22 58 or %i4, 0x258, %i4
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
400173e4: c8 48 40 00 ldsb [ %g1 ], %g4
400173e8: 80 a1 20 00 cmp %g4, 0
400173ec: 02 80 00 0e be 40017424 <_Objects_Get_name_as_string+0xfc>
400173f0: c4 08 40 00 ldub [ %g1 ], %g2
*d = (isprint((unsigned char)*s)) ? *s : '*';
400173f4: fa 07 00 00 ld [ %i4 ], %i5
400173f8: 88 08 a0 ff and %g2, 0xff, %g4
400173fc: 88 07 40 04 add %i5, %g4, %g4
40017400: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
40017404: 80 89 20 97 btst 0x97, %g4
40017408: 12 80 00 03 bne 40017414 <_Objects_Get_name_as_string+0xec>
4001740c: 82 00 60 01 inc %g1
40017410: 84 10 20 2a mov 0x2a, %g2
40017414: c4 28 c0 00 stb %g2, [ %g3 ]
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
40017418: 80 a0 40 1b cmp %g1, %i3
4001741c: 12 bf ff f2 bne 400173e4 <_Objects_Get_name_as_string+0xbc>
40017420: 86 00 e0 01 inc %g3
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
_Thread_Enable_dispatch();
40017424: 7f ff e4 a3 call 400106b0 <_Thread_Enable_dispatch>
40017428: c0 28 c0 00 clrb [ %g3 ]
return name;
}
return NULL; /* unreachable path */
}
4001742c: 81 c7 e0 08 ret
40017430: 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;
40017434: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40017438: 10 bf ff c4 b 40017348 <_Objects_Get_name_as_string+0x20>
4001743c: fa 00 60 08 ld [ %g1 + 8 ], %i5
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
40017440: 80 a0 60 00 cmp %g1, 0
40017444: 12 bf ff dc bne 400173b4 <_Objects_Get_name_as_string+0x8c>
40017448: 80 a6 60 01 cmp %i1, 1
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
4001744c: 86 10 00 1a mov %i2, %g3
}
}
*d = '\0';
_Thread_Enable_dispatch();
40017450: 7f ff e4 98 call 400106b0 <_Thread_Enable_dispatch>
40017454: c0 28 c0 00 clrb [ %g3 ]
40017458: 30 bf ff f5 b,a 4001742c <_Objects_Get_name_as_string+0x104>
4001a1f8 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
4001a1f8: 9d e3 bf a0 save %sp, -96, %sp
Objects_Control *object;
Objects_Id next_id;
if ( !information )
4001a1fc: 80 a6 20 00 cmp %i0, 0
4001a200: 02 80 00 29 be 4001a2a4 <_Objects_Get_next+0xac>
4001a204: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( !location_p )
4001a208: 02 80 00 27 be 4001a2a4 <_Objects_Get_next+0xac>
4001a20c: 80 a6 e0 00 cmp %i3, 0
return NULL;
if ( !next_id_p )
4001a210: 02 80 00 25 be 4001a2a4 <_Objects_Get_next+0xac>
4001a214: 83 2e 60 10 sll %i1, 0x10, %g1
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
4001a218: 80 a0 60 00 cmp %g1, 0
4001a21c: 22 80 00 13 be,a 4001a268 <_Objects_Get_next+0x70>
4001a220: 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)
4001a224: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
4001a228: 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);
4001a22c: 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)
4001a230: 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);
4001a234: 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)
4001a238: 80 a0 80 01 cmp %g2, %g1
4001a23c: 0a 80 00 13 bcs 4001a288 <_Objects_Get_next+0x90>
4001a240: 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);
4001a244: 7f ff d5 0f call 4000f680 <_Objects_Get>
4001a248: b2 06 60 01 inc %i1
next_id++;
} while (*location_p != OBJECTS_LOCAL);
4001a24c: c2 06 80 00 ld [ %i2 ], %g1
4001a250: 80 a0 60 00 cmp %g1, 0
4001a254: 32 bf ff f5 bne,a 4001a228 <_Objects_Get_next+0x30>
4001a258: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
*next_id_p = next_id;
4001a25c: f2 26 c0 00 st %i1, [ %i3 ]
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
4001a260: 81 c7 e0 08 ret
4001a264: 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)
4001a268: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
4001a26c: 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);
4001a270: 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)
4001a274: 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);
4001a278: 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)
4001a27c: 80 a0 80 01 cmp %g2, %g1
4001a280: 1a bf ff f1 bcc 4001a244 <_Objects_Get_next+0x4c> <== ALWAYS TAKEN
4001a284: 94 10 00 1a mov %i2, %o2
{
*location_p = OBJECTS_ERROR;
4001a288: 82 10 20 01 mov 1, %g1
4001a28c: c2 26 80 00 st %g1, [ %i2 ]
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
4001a290: 90 10 20 00 clr %o0
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
4001a294: 82 10 3f ff mov -1, %g1
4001a298: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
4001a29c: 81 c7 e0 08 ret
4001a2a0: 91 e8 00 08 restore %g0, %o0, %o0
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
4001a2a4: 10 bf ff ef b 4001a260 <_Objects_Get_next+0x68>
4001a2a8: 90 10 20 00 clr %o0
4001a43c <_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;
4001a43c: c4 02 20 08 ld [ %o0 + 8 ], %g2
if ( information->maximum >= index ) {
4001a440: 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;
4001a444: 92 22 40 02 sub %o1, %g2, %o1
4001a448: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
4001a44c: 80 a2 40 01 cmp %o1, %g1
4001a450: 18 80 00 09 bgu 4001a474 <_Objects_Get_no_protection+0x38>
4001a454: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
4001a458: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4001a45c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
4001a460: 80 a2 20 00 cmp %o0, 0
4001a464: 02 80 00 05 be 4001a478 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
4001a468: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
4001a46c: 81 c3 e0 08 retl
4001a470: 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;
4001a474: 82 10 20 01 mov 1, %g1
return NULL;
4001a478: 90 10 20 00 clr %o0
}
4001a47c: 81 c3 e0 08 retl
4001a480: c2 22 80 00 st %g1, [ %o2 ]
4000f6f4 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
4000f6f4: 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;
4000f6f8: 80 a6 20 00 cmp %i0, 0
4000f6fc: 12 80 00 06 bne 4000f714 <_Objects_Id_to_name+0x20>
4000f700: 83 36 20 18 srl %i0, 0x18, %g1
4000f704: 03 10 00 ca sethi %hi(0x40032800), %g1
4000f708: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 40032820 <_Per_CPU_Information+0x10>
4000f70c: f0 00 60 08 ld [ %g1 + 8 ], %i0
4000f710: 83 36 20 18 srl %i0, 0x18, %g1
4000f714: 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 )
4000f718: 84 00 7f ff add %g1, -1, %g2
4000f71c: 80 a0 a0 02 cmp %g2, 2
4000f720: 18 80 00 11 bgu 4000f764 <_Objects_Id_to_name+0x70>
4000f724: 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 ] )
4000f728: 05 10 00 c8 sethi %hi(0x40032000), %g2
4000f72c: 84 10 a2 24 or %g2, 0x224, %g2 ! 40032224 <_Objects_Information_table>
4000f730: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000f734: 80 a0 60 00 cmp %g1, 0
4000f738: 02 80 00 0b be 4000f764 <_Objects_Id_to_name+0x70>
4000f73c: 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 ];
4000f740: 85 28 a0 02 sll %g2, 2, %g2
4000f744: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
4000f748: 80 a2 20 00 cmp %o0, 0
4000f74c: 02 80 00 06 be 4000f764 <_Objects_Id_to_name+0x70> <== NEVER TAKEN
4000f750: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
4000f754: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
4000f758: 80 a0 60 00 cmp %g1, 0
4000f75c: 02 80 00 04 be 4000f76c <_Objects_Id_to_name+0x78> <== ALWAYS TAKEN
4000f760: 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;
4000f764: 81 c7 e0 08 ret
4000f768: 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 );
4000f76c: 7f ff ff c5 call 4000f680 <_Objects_Get>
4000f770: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
4000f774: 80 a2 20 00 cmp %o0, 0
4000f778: 02 bf ff fb be 4000f764 <_Objects_Id_to_name+0x70>
4000f77c: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
4000f780: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
4000f784: 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();
4000f788: 40 00 03 ca call 400106b0 <_Thread_Enable_dispatch>
4000f78c: c2 26 40 00 st %g1, [ %i1 ]
4000f790: 81 c7 e0 08 ret
4000f794: 81 e8 00 00 restore
40009164 <_Objects_Shrink_information>:
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
40009164: 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 );
40009168: f8 16 20 0a lduh [ %i0 + 0xa ], %i4
block_count = (information->maximum - index_base) /
4000916c: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3
40009170: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0
40009174: 92 10 00 1b mov %i3, %o1
40009178: 40 00 3d bf call 40018874 <.udiv>
4000917c: 90 22 00 1c sub %o0, %i4, %o0
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
40009180: 80 a2 20 00 cmp %o0, 0
40009184: 02 80 00 36 be 4000925c <_Objects_Shrink_information+0xf8><== NEVER TAKEN
40009188: 01 00 00 00 nop
if ( information->inactive_per_block[ block ] ==
4000918c: c8 06 20 30 ld [ %i0 + 0x30 ], %g4
40009190: c2 01 00 00 ld [ %g4 ], %g1
40009194: 80 a6 c0 01 cmp %i3, %g1
40009198: 02 80 00 0f be 400091d4 <_Objects_Shrink_information+0x70><== NEVER TAKEN
4000919c: 82 10 20 00 clr %g1
400091a0: 10 80 00 07 b 400091bc <_Objects_Shrink_information+0x58>
400091a4: ba 10 20 04 mov 4, %i5
400091a8: c4 01 00 1d ld [ %g4 + %i5 ], %g2
400091ac: 80 a6 c0 02 cmp %i3, %g2
400091b0: 02 80 00 0a be 400091d8 <_Objects_Shrink_information+0x74>
400091b4: 86 07 60 04 add %i5, 4, %g3
400091b8: 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++ ) {
400091bc: 82 00 60 01 inc %g1
400091c0: 80 a0 40 08 cmp %g1, %o0
400091c4: 12 bf ff f9 bne 400091a8 <_Objects_Shrink_information+0x44>
400091c8: b8 07 00 1b add %i4, %i3, %i4
400091cc: 81 c7 e0 08 ret
400091d0: 81 e8 00 00 restore
if ( information->inactive_per_block[ block ] ==
400091d4: 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 );
400091d8: 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;
400091dc: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
400091e0: 10 80 00 05 b 400091f4 <_Objects_Shrink_information+0x90>
400091e4: 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 );
400091e8: 90 96 e0 00 orcc %i3, 0, %o0
400091ec: 22 80 00 12 be,a 40009234 <_Objects_Shrink_information+0xd0>
400091f0: 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 );
400091f4: c2 02 20 08 ld [ %o0 + 8 ], %g1
400091f8: 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) &&
400091fc: 80 a0 40 1c cmp %g1, %i4
40009200: 0a bf ff fa bcs 400091e8 <_Objects_Shrink_information+0x84>
40009204: f6 02 00 00 ld [ %o0 ], %i3
(index < (index_base + information->allocation_size))) {
40009208: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
4000920c: 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) &&
40009210: 80 a0 40 02 cmp %g1, %g2
40009214: 3a bf ff f6 bcc,a 400091ec <_Objects_Shrink_information+0x88>
40009218: 90 96 e0 00 orcc %i3, 0, %o0
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
4000921c: 40 00 10 2f call 4000d2d8 <_Chain_Extract>
40009220: 01 00 00 00 nop
}
}
while ( the_object );
40009224: 90 96 e0 00 orcc %i3, 0, %o0
40009228: 32 bf ff f4 bne,a 400091f8 <_Objects_Shrink_information+0x94><== ALWAYS TAKEN
4000922c: 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 ] );
40009230: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
40009234: 40 00 07 7e call 4000b02c <_Workspace_Free>
40009238: d0 00 40 1d ld [ %g1 + %i5 ], %o0
information->object_blocks[ block ] = NULL;
4000923c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
40009240: 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;
40009244: c0 20 40 1d clr [ %g1 + %i5 ]
information->inactive_per_block[ block ] = 0;
40009248: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive -= information->allocation_size;
4000924c: 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;
40009250: c0 20 c0 1d clr [ %g3 + %i5 ]
information->inactive -= information->allocation_size;
40009254: 82 20 80 01 sub %g2, %g1, %g1
40009258: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
return;
4000925c: 81 c7 e0 08 ret
40009260: 81 e8 00 00 restore
4000ef14 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4000ef14: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4000ef18: 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 ];
4000ef1c: 35 00 00 3f sethi %hi(0xfc00), %i2
4000ef20: b3 30 60 18 srl %g1, 0x18, %i1
4000ef24: b4 16 a3 ff or %i2, 0x3ff, %i2
4000ef28: b2 0e 60 07 and %i1, 7, %i1
4000ef2c: b4 08 40 1a and %g1, %i2, %i2
4000ef30: b2 06 60 04 add %i1, 4, %i1
4000ef34: 3b 10 00 7c sethi %hi(0x4001f000), %i5
4000ef38: b5 2e a0 02 sll %i2, 2, %i2
4000ef3c: ba 17 62 9c or %i5, 0x29c, %i5
4000ef40: 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 ) {
4000ef44: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
4000ef48: 80 a0 60 00 cmp %g1, 0
4000ef4c: 02 80 00 21 be 4000efd0 <_POSIX_Keys_Run_destructors+0xbc>
4000ef50: b8 10 20 01 mov 1, %i4
4000ef54: 86 10 20 01 mov 1, %g3
4000ef58: b6 10 00 01 mov %g1, %i3
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
4000ef5c: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
_POSIX_Keys_Information.local_table [ index ];
4000ef60: 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 *)
4000ef64: 85 30 a0 0e srl %g2, 0xe, %g2
4000ef68: c4 01 00 02 ld [ %g4 + %g2 ], %g2
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
4000ef6c: 80 a0 a0 00 cmp %g2, 0
4000ef70: 02 80 00 10 be 4000efb0 <_POSIX_Keys_Run_destructors+0x9c>
4000ef74: 82 00 80 19 add %g2, %i1, %g1
4000ef78: c8 00 a0 10 ld [ %g2 + 0x10 ], %g4
4000ef7c: 80 a1 20 00 cmp %g4, 0
4000ef80: 22 80 00 0d be,a 4000efb4 <_POSIX_Keys_Run_destructors+0xa0>
4000ef84: b8 07 20 01 inc %i4
void *value = key->Values [ thread_api ][ thread_index ];
4000ef88: c8 00 60 04 ld [ %g1 + 4 ], %g4
4000ef8c: d0 01 00 1a ld [ %g4 + %i2 ], %o0
if ( value != NULL ) {
4000ef90: 80 a2 20 00 cmp %o0, 0
4000ef94: 22 80 00 08 be,a 4000efb4 <_POSIX_Keys_Run_destructors+0xa0><== ALWAYS TAKEN
4000ef98: b8 07 20 01 inc %i4
key->Values [ thread_api ][ thread_index ] = NULL;
4000ef9c: c0 21 00 1a clr [ %g4 + %i2 ] <== NOT EXECUTED
(*key->destructor)( value );
4000efa0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED
4000efa4: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000efa8: 01 00 00 00 nop <== NOT EXECUTED
done = false;
4000efac: 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 ) {
4000efb0: b8 07 20 01 inc %i4
4000efb4: 85 2f 20 10 sll %i4, 0x10, %g2
4000efb8: 85 30 a0 10 srl %g2, 0x10, %g2
4000efbc: 80 a6 c0 02 cmp %i3, %g2
4000efc0: 1a bf ff e7 bcc 4000ef5c <_POSIX_Keys_Run_destructors+0x48>
4000efc4: 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 ) {
4000efc8: 22 bf ff e0 be,a 4000ef48 <_POSIX_Keys_Run_destructors+0x34><== NEVER TAKEN
4000efcc: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
4000efd0: 81 c7 e0 08 ret
4000efd4: 81 e8 00 00 restore
4000c228 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
4000c228: 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(
4000c22c: 11 10 00 a3 sethi %hi(0x40028c00), %o0
4000c230: 92 10 00 18 mov %i0, %o1
4000c234: 90 12 23 a0 or %o0, 0x3a0, %o0
4000c238: 40 00 0d 8d call 4000f86c <_Objects_Get>
4000c23c: 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 ) {
4000c240: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000c244: 80 a0 60 00 cmp %g1, 0
4000c248: 22 80 00 08 be,a 4000c268 <_POSIX_Message_queue_Receive_support+0x40>
4000c24c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
4000c250: 40 00 29 59 call 400167b4 <__errno>
4000c254: b0 10 3f ff mov -1, %i0
4000c258: 82 10 20 09 mov 9, %g1
4000c25c: c2 22 00 00 st %g1, [ %o0 ]
}
4000c260: 81 c7 e0 08 ret
4000c264: 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 ) {
4000c268: 84 08 60 03 and %g1, 3, %g2
4000c26c: 80 a0 a0 01 cmp %g2, 1
4000c270: 02 80 00 39 be 4000c354 <_POSIX_Message_queue_Receive_support+0x12c>
4000c274: 01 00 00 00 nop
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
4000c278: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
4000c27c: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
4000c280: 80 a0 80 1a cmp %g2, %i2
4000c284: 18 80 00 23 bgu 4000c310 <_POSIX_Message_queue_Receive_support+0xe8>
4000c288: 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;
4000c28c: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4000c290: 80 a7 20 00 cmp %i4, 0
4000c294: 12 80 00 1b bne 4000c300 <_POSIX_Message_queue_Receive_support+0xd8>
4000c298: 98 10 20 00 clr %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
4000c29c: 9a 10 00 1d mov %i5, %o5
4000c2a0: 90 02 20 1c add %o0, 0x1c, %o0
4000c2a4: 92 10 00 18 mov %i0, %o1
4000c2a8: 94 10 00 19 mov %i1, %o2
4000c2ac: 96 07 bf fc add %fp, -4, %o3
4000c2b0: 40 00 08 f2 call 4000e678 <_CORE_message_queue_Seize>
4000c2b4: 98 0b 20 01 and %o4, 1, %o4
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
4000c2b8: 40 00 11 48 call 400107d8 <_Thread_Enable_dispatch>
4000c2bc: 3b 10 00 a4 sethi %hi(0x40029000), %i5
if (msg_prio) {
4000c2c0: 80 a6 e0 00 cmp %i3, 0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
4000c2c4: ba 17 60 20 or %i5, 0x20, %i5
do_wait,
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
4000c2c8: 02 80 00 07 be 4000c2e4 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN
4000c2cc: 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);
4000c2d0: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
4000c2d4: 85 38 e0 1f sra %g3, 0x1f, %g2
4000c2d8: 86 18 80 03 xor %g2, %g3, %g3
4000c2dc: 84 20 c0 02 sub %g3, %g2, %g2
*msg_prio = _POSIX_Message_queue_Priority_from_core(
4000c2e0: c4 26 c0 00 st %g2, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
4000c2e4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
4000c2e8: 80 a0 60 00 cmp %g1, 0
4000c2ec: 12 80 00 11 bne 4000c330 <_POSIX_Message_queue_Receive_support+0x108>
4000c2f0: 01 00 00 00 nop
return length_out;
4000c2f4: f0 07 bf fc ld [ %fp + -4 ], %i0
4000c2f8: 81 c7 e0 08 ret
4000c2fc: 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;
4000c300: 99 30 60 0e srl %g1, 0xe, %o4
4000c304: 98 1b 20 01 xor %o4, 1, %o4
4000c308: 10 bf ff e5 b 4000c29c <_POSIX_Message_queue_Receive_support+0x74>
4000c30c: 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();
4000c310: 40 00 11 32 call 400107d8 <_Thread_Enable_dispatch>
4000c314: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4000c318: 40 00 29 27 call 400167b4 <__errno>
4000c31c: 01 00 00 00 nop
4000c320: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
4000c324: c2 22 00 00 st %g1, [ %o0 ]
4000c328: 81 c7 e0 08 ret
4000c32c: 81 e8 00 00 restore
}
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
4000c330: 40 00 29 21 call 400167b4 <__errno>
4000c334: b0 10 3f ff mov -1, %i0
4000c338: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000c33c: b8 10 00 08 mov %o0, %i4
4000c340: 40 00 00 a2 call 4000c5c8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4000c344: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
4000c348: d0 27 00 00 st %o0, [ %i4 ]
4000c34c: 81 c7 e0 08 ret
4000c350: 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();
4000c354: 40 00 11 21 call 400107d8 <_Thread_Enable_dispatch>
4000c358: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EBADF );
4000c35c: 40 00 29 16 call 400167b4 <__errno>
4000c360: 01 00 00 00 nop
4000c364: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4000c368: c2 22 00 00 st %g1, [ %o0 ]
4000c36c: 81 c7 e0 08 ret
4000c370: 81 e8 00 00 restore
4000ecf0 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
4000ecf0: 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)
4000ecf4: 80 a6 a0 00 cmp %i2, 0
4000ecf8: 12 80 00 2f bne 4000edb4 <_POSIX_Semaphore_Create_support+0xc4>
4000ecfc: 03 10 00 8e sethi %hi(0x40023800), %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;
4000ed00: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 400238c0 <_Thread_Dispatch_disable_level>
++level;
4000ed04: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4000ed08: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
4000ed0c: 35 10 00 8e sethi %hi(0x40023800), %i2
4000ed10: 7f ff ee 48 call 4000a630 <_Objects_Allocate>
4000ed14: 90 16 a3 84 or %i2, 0x384, %o0 ! 40023b84 <_POSIX_Semaphore_Information>
rtems_set_errno_and_return_minus_one( ENOSYS );
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
4000ed18: ba 92 20 00 orcc %o0, 0, %i5
4000ed1c: 02 80 00 2c be 4000edcc <_POSIX_Semaphore_Create_support+0xdc>
4000ed20: 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 ) {
4000ed24: 02 80 00 1e be 4000ed9c <_POSIX_Semaphore_Create_support+0xac>
4000ed28: 92 10 00 19 mov %i1, %o1
name = _Workspace_String_duplicate( name_arg, name_len );
4000ed2c: 40 00 04 10 call 4000fd6c <_Workspace_String_duplicate>
4000ed30: 90 10 00 18 mov %i0, %o0
if ( !name ) {
4000ed34: b2 92 20 00 orcc %o0, 0, %i1
4000ed38: 02 80 00 2d be 4000edec <_POSIX_Semaphore_Create_support+0xfc><== NEVER TAKEN
4000ed3c: 82 10 20 01 mov 1, %g1
}
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
4000ed40: 84 10 20 01 mov 1, %g2
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
4000ed44: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( name ) {
the_semaphore->named = true;
4000ed48: c4 2f 60 14 stb %g2, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
4000ed4c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
4000ed50: 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;
4000ed54: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000ed58: 90 07 60 1c add %i5, 0x1c, %o0
4000ed5c: 92 07 60 5c add %i5, 0x5c, %o1
4000ed60: 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;
4000ed64: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000ed68: 7f ff ec 8f call 40009fa4 <_CORE_semaphore_Initialize>
4000ed6c: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
4000ed70: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000ed74: b4 16 a3 84 or %i2, 0x384, %i2
4000ed78: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
4000ed7c: 83 28 60 02 sll %g1, 2, %g1
4000ed80: 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;
4000ed84: f2 27 60 0c st %i1, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
4000ed88: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
4000ed8c: 7f ff f3 75 call 4000bb60 <_Thread_Enable_dispatch>
4000ed90: b0 10 20 00 clr %i0
return 0;
4000ed94: 81 c7 e0 08 ret
4000ed98: 81 e8 00 00 restore
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
4000ed9c: 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;
4000eda0: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
4000eda4: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
4000eda8: 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;
4000edac: 10 bf ff ea b 4000ed54 <_POSIX_Semaphore_Create_support+0x64>
4000edb0: 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 );
4000edb4: 40 00 0a 2a call 4001165c <__errno>
4000edb8: b0 10 3f ff mov -1, %i0
4000edbc: 82 10 20 58 mov 0x58, %g1
4000edc0: c2 22 00 00 st %g1, [ %o0 ]
4000edc4: 81 c7 e0 08 ret
4000edc8: 81 e8 00 00 restore
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
4000edcc: 7f ff f3 65 call 4000bb60 <_Thread_Enable_dispatch>
4000edd0: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( ENOSPC );
4000edd4: 40 00 0a 22 call 4001165c <__errno>
4000edd8: 01 00 00 00 nop
4000eddc: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
4000ede0: c2 22 00 00 st %g1, [ %o0 ]
4000ede4: 81 c7 e0 08 ret
4000ede8: 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 );
4000edec: 90 16 a3 84 or %i2, 0x384, %o0 <== NOT EXECUTED
4000edf0: 7f ff ef 08 call 4000aa10 <_Objects_Free> <== NOT EXECUTED
4000edf4: 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();
4000edf8: 7f ff f3 5a call 4000bb60 <_Thread_Enable_dispatch> <== NOT EXECUTED
4000edfc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000ee00: 40 00 0a 17 call 4001165c <__errno> <== NOT EXECUTED
4000ee04: 01 00 00 00 nop <== NOT EXECUTED
4000ee08: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
4000ee0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000ee10: 81 c7 e0 08 ret <== NOT EXECUTED
4000ee14: 81 e8 00 00 restore <== NOT EXECUTED
4000c3a4 <_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 ];
4000c3a4: c2 02 21 50 ld [ %o0 + 0x150 ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4000c3a8: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
4000c3ac: 80 a0 a0 00 cmp %g2, 0
4000c3b0: 12 80 00 06 bne 4000c3c8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24><== NEVER TAKEN
4000c3b4: 01 00 00 00 nop
4000c3b8: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
4000c3bc: 80 a0 a0 01 cmp %g2, 1
4000c3c0: 22 80 00 05 be,a 4000c3d4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30>
4000c3c4: 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();
4000c3c8: 82 13 c0 00 mov %o7, %g1
4000c3cc: 7f ff f6 3c call 40009cbc <_Thread_Enable_dispatch>
4000c3d0: 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 &&
4000c3d4: 80 a0 60 00 cmp %g1, 0
4000c3d8: 02 bf ff fc be 4000c3c8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
4000c3dc: 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;
4000c3e0: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000c3e4: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40017cf0 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4000c3e8: 92 10 3f ff mov -1, %o1
--level;
4000c3ec: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000c3f0: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ]
4000c3f4: 82 13 c0 00 mov %o7, %g1
4000c3f8: 40 00 01 d9 call 4000cb5c <_POSIX_Thread_Exit>
4000c3fc: 9e 10 40 00 mov %g1, %o7
4000d8a0 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4000d8a0: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4000d8a4: 7f ff ff f2 call 4000d86c <_POSIX_Priority_Is_valid>
4000d8a8: d0 06 40 00 ld [ %i1 ], %o0
4000d8ac: 80 8a 20 ff btst 0xff, %o0
4000d8b0: 32 80 00 04 bne,a 4000d8c0 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
4000d8b4: c0 26 80 00 clr [ %i2 ]
return EINVAL;
4000d8b8: 81 c7 e0 08 ret
4000d8bc: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
4000d8c0: 80 a6 20 00 cmp %i0, 0
4000d8c4: 02 80 00 2c be 4000d974 <_POSIX_Thread_Translate_sched_param+0xd4>
4000d8c8: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
4000d8cc: 80 a6 20 01 cmp %i0, 1
4000d8d0: 02 80 00 2d be 4000d984 <_POSIX_Thread_Translate_sched_param+0xe4>
4000d8d4: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4000d8d8: 02 80 00 2d be 4000d98c <_POSIX_Thread_Translate_sched_param+0xec>
4000d8dc: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
4000d8e0: 12 bf ff f6 bne 4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d8e4: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4000d8e8: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000d8ec: 80 a0 60 00 cmp %g1, 0
4000d8f0: 32 80 00 07 bne,a 4000d90c <_POSIX_Thread_Translate_sched_param+0x6c>
4000d8f4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000d8f8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000d8fc: 80 a0 60 00 cmp %g1, 0
4000d900: 02 bf ff ee be 4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d904: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4000d908: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000d90c: 80 a0 60 00 cmp %g1, 0
4000d910: 12 80 00 06 bne 4000d928 <_POSIX_Thread_Translate_sched_param+0x88>
4000d914: 01 00 00 00 nop
4000d918: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000d91c: 80 a0 60 00 cmp %g1, 0
4000d920: 02 bf ff e6 be 4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d924: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4000d928: 7f ff f7 45 call 4000b63c <_Timespec_To_ticks>
4000d92c: 90 06 60 08 add %i1, 8, %o0
4000d930: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4000d934: 7f ff f7 42 call 4000b63c <_Timespec_To_ticks>
4000d938: 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 ) <
4000d93c: 80 a7 40 08 cmp %i5, %o0
4000d940: 0a bf ff de bcs 4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d944: 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 ) )
4000d948: 7f ff ff c9 call 4000d86c <_POSIX_Priority_Is_valid>
4000d94c: d0 06 60 04 ld [ %i1 + 4 ], %o0
4000d950: 80 8a 20 ff btst 0xff, %o0
4000d954: 02 bf ff d9 be 4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d958: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4000d95c: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4000d960: 03 10 00 1d sethi %hi(0x40007400), %g1
4000d964: 82 10 62 ac or %g1, 0x2ac, %g1 ! 400076ac <_POSIX_Threads_Sporadic_budget_callout>
4000d968: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
4000d96c: 81 c7 e0 08 ret
4000d970: 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;
4000d974: 82 10 20 01 mov 1, %g1
4000d978: c2 26 80 00 st %g1, [ %i2 ]
return 0;
4000d97c: 81 c7 e0 08 ret
4000d980: 81 e8 00 00 restore
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
4000d984: 81 c7 e0 08 ret
4000d988: 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;
4000d98c: f0 26 80 00 st %i0, [ %i2 ]
return 0;
4000d990: 81 c7 e0 08 ret
4000d994: 91 e8 20 00 restore %g0, 0, %o0
4000cadc <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
4000cadc: 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 ];
4000cae0: f0 06 61 50 ld [ %i1 + 0x150 ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
4000cae4: 40 00 08 f0 call 4000eea4 <_POSIX_Threads_cancel_run>
4000cae8: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
4000caec: 90 10 00 19 mov %i1, %o0
4000caf0: 40 00 09 09 call 4000ef14 <_POSIX_Keys_Run_destructors>
4000caf4: 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 )) )
4000caf8: 10 80 00 03 b 4000cb04 <_POSIX_Threads_Delete_extension+0x28>
4000cafc: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
4000cb00: 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 )) )
4000cb04: 7f ff f5 ca call 4000a22c <_Thread_queue_Dequeue>
4000cb08: 90 10 00 1d mov %i5, %o0
4000cb0c: 80 a2 20 00 cmp %o0, 0
4000cb10: 32 bf ff fc bne,a 4000cb00 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
4000cb14: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
4000cb18: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4000cb1c: 80 a0 60 04 cmp %g1, 4
4000cb20: 02 80 00 05 be 4000cb34 <_POSIX_Threads_Delete_extension+0x58>
4000cb24: 01 00 00 00 nop
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4000cb28: c0 26 61 50 clr [ %i1 + 0x150 ]
_Workspace_Free( api );
4000cb2c: 7f ff f9 40 call 4000b02c <_Workspace_Free>
4000cb30: 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 );
4000cb34: 7f ff f8 80 call 4000ad34 <_Watchdog_Remove>
4000cb38: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4000cb3c: c0 26 61 50 clr [ %i1 + 0x150 ]
_Workspace_Free( api );
4000cb40: 7f ff f9 3b call 4000b02c <_Workspace_Free>
4000cb44: 81 e8 00 00 restore
400073c0 <_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)
{
400073c0: 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;
400073c4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
400073c8: 82 10 62 04 or %g1, 0x204, %g1 ! 4001ee04 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
400073cc: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
400073d0: 80 a6 e0 00 cmp %i3, 0
400073d4: 02 80 00 18 be 40007434 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400073d8: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
400073dc: 80 a7 60 00 cmp %i5, 0
400073e0: 02 80 00 15 be 40007434 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400073e4: 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 );
400073e8: 40 00 19 6c call 4000d998 <pthread_attr_init>
400073ec: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
400073f0: 92 10 20 02 mov 2, %o1
400073f4: 40 00 19 75 call 4000d9c8 <pthread_attr_setinheritsched>
400073f8: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
400073fc: d2 07 60 04 ld [ %i5 + 4 ], %o1
40007400: 40 00 19 82 call 4000da08 <pthread_attr_setstacksize>
40007404: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
40007408: d4 07 40 00 ld [ %i5 ], %o2
4000740c: 90 07 bf bc add %fp, -68, %o0
40007410: 92 07 bf c0 add %fp, -64, %o1
40007414: 7f ff ff 00 call 40007014 <pthread_create>
40007418: 96 10 20 00 clr %o3
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
4000741c: 94 92 20 00 orcc %o0, 0, %o2
40007420: 12 80 00 07 bne 4000743c <_POSIX_Threads_Initialize_user_threads_body+0x7c>
40007424: 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++ ) {
40007428: 80 a7 00 1b cmp %i4, %i3
4000742c: 12 bf ff ef bne 400073e8 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
40007430: ba 07 60 08 add %i5, 8, %i5
40007434: 81 c7 e0 08 ret
40007438: 81 e8 00 00 restore
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
4000743c: 90 10 20 02 mov 2, %o0
40007440: 40 00 08 79 call 40009624 <_Internal_error_Occurred>
40007444: 92 10 20 01 mov 1, %o1
4000cc68 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4000cc68: 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 ];
4000cc6c: 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 );
4000cc70: 40 00 03 bb call 4000db5c <_Timespec_To_ticks>
4000cc74: 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);
4000cc78: c4 07 60 88 ld [ %i5 + 0x88 ], %g2
4000cc7c: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000cc80: d2 08 62 dc ldub [ %g1 + 0x2dc ], %o1 ! 4001e2dc <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 ) {
4000cc84: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4000cc88: 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;
4000cc8c: 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 ) {
4000cc90: 80 a0 60 00 cmp %g1, 0
4000cc94: 12 80 00 06 bne 4000ccac <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NEVER TAKEN
4000cc98: 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 ) {
4000cc9c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000cca0: 80 a0 40 09 cmp %g1, %o1
4000cca4: 18 80 00 09 bgu 4000ccc8 <_POSIX_Threads_Sporadic_budget_TSR+0x60>
4000cca8: 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 );
4000ccac: 90 07 60 90 add %i5, 0x90, %o0
4000ccb0: 40 00 03 ab call 4000db5c <_Timespec_To_ticks>
4000ccb4: 31 10 00 7b sethi %hi(0x4001ec00), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000ccb8: b2 07 60 a8 add %i5, 0xa8, %i1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000ccbc: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000ccc0: 7f ff f7 be call 4000abb8 <_Watchdog_Insert>
4000ccc4: 91 ee 23 58 restore %i0, 0x358, %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 );
4000ccc8: 7f ff f3 46 call 400099e0 <_Thread_Change_priority>
4000cccc: 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 );
4000ccd0: 90 07 60 90 add %i5, 0x90, %o0
4000ccd4: 40 00 03 a2 call 4000db5c <_Timespec_To_ticks>
4000ccd8: 31 10 00 7b sethi %hi(0x4001ec00), %i0
4000ccdc: b2 07 60 a8 add %i5, 0xa8, %i1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000cce0: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000cce4: 7f ff f7 b5 call 4000abb8 <_Watchdog_Insert>
4000cce8: 91 ee 23 58 restore %i0, 0x358, %o0
4000ccec <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000ccec: c4 02 21 50 ld [ %o0 + 0x150 ], %g2
4000ccf0: c6 00 a0 8c ld [ %g2 + 0x8c ], %g3
4000ccf4: 05 10 00 78 sethi %hi(0x4001e000), %g2
4000ccf8: d2 08 a2 dc ldub [ %g2 + 0x2dc ], %o1 ! 4001e2dc <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 ) {
4000ccfc: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
4000cd00: 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 */
4000cd04: 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;
4000cd08: 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 ) {
4000cd0c: 80 a0 a0 00 cmp %g2, 0
4000cd10: 12 80 00 06 bne 4000cd28 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NEVER TAKEN
4000cd14: 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 ) {
4000cd18: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000cd1c: 80 a0 40 09 cmp %g1, %o1
4000cd20: 0a 80 00 04 bcs 4000cd30 <_POSIX_Threads_Sporadic_budget_callout+0x44><== ALWAYS TAKEN
4000cd24: 94 10 20 01 mov 1, %o2
4000cd28: 81 c3 e0 08 retl <== NOT EXECUTED
4000cd2c: 01 00 00 00 nop <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
4000cd30: 82 13 c0 00 mov %o7, %g1
4000cd34: 7f ff f3 2b call 400099e0 <_Thread_Change_priority>
4000cd38: 9e 10 40 00 mov %g1, %o7
4000eea4 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
4000eea4: 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 ];
4000eea8: f8 06 21 50 ld [ %i0 + 0x150 ], %i4
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
4000eeac: 84 10 20 01 mov 1, %g2
while ( !_Chain_Is_empty( handler_stack ) ) {
4000eeb0: 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 );
4000eeb4: b6 07 20 e8 add %i4, 0xe8, %i3
4000eeb8: 80 a0 40 1b cmp %g1, %i3
4000eebc: 02 80 00 14 be 4000ef0c <_POSIX_Threads_cancel_run+0x68>
4000eec0: c4 27 20 d8 st %g2, [ %i4 + 0xd8 ]
_ISR_Disable( level );
4000eec4: 7f ff cc 78 call 400020a4 <sparc_disable_interrupts>
4000eec8: 01 00 00 00 nop
handler = (POSIX_Cancel_Handler_control *)
4000eecc: fa 07 20 ec ld [ %i4 + 0xec ], %i5
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000eed0: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
4000eed4: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
4000eed8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000eedc: c4 20 40 00 st %g2, [ %g1 ]
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
4000eee0: 7f ff cc 75 call 400020b4 <sparc_enable_interrupts>
4000eee4: 01 00 00 00 nop
(*handler->routine)( handler->arg );
4000eee8: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000eeec: 9f c0 40 00 call %g1
4000eef0: d0 07 60 0c ld [ %i5 + 0xc ], %o0
_Workspace_Free( handler );
4000eef4: 7f ff f0 4e call 4000b02c <_Workspace_Free>
4000eef8: 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 ) ) {
4000eefc: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
4000ef00: 80 a0 40 1b cmp %g1, %i3
4000ef04: 12 bf ff f0 bne 4000eec4 <_POSIX_Threads_cancel_run+0x20> <== NEVER TAKEN
4000ef08: 01 00 00 00 nop
4000ef0c: 81 c7 e0 08 ret
4000ef10: 81 e8 00 00 restore
4000714c <_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)
{
4000714c: 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;
40007150: c4 06 60 68 ld [ %i1 + 0x68 ], %g2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
40007154: 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;
40007158: 84 00 a0 01 inc %g2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
4000715c: 80 a0 60 00 cmp %g1, 0
40007160: 12 80 00 0e bne 40007198 <_POSIX_Timer_TSR+0x4c>
40007164: c4 26 60 68 st %g2, [ %i1 + 0x68 ]
40007168: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
4000716c: 80 a0 60 00 cmp %g1, 0
40007170: 32 80 00 0b bne,a 4000719c <_POSIX_Timer_TSR+0x50> <== ALWAYS TAKEN
40007174: 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;
40007178: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
4000717c: 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 ) ) {
40007180: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
40007184: 40 00 18 1c call 4000d1f4 <pthread_kill>
40007188: 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;
4000718c: c0 26 60 68 clr [ %i1 + 0x68 ]
40007190: 81 c7 e0 08 ret
40007194: 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(
40007198: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
4000719c: d4 06 60 08 ld [ %i1 + 8 ], %o2
400071a0: 90 06 60 10 add %i1, 0x10, %o0
400071a4: 98 10 00 19 mov %i1, %o4
400071a8: 17 10 00 1c sethi %hi(0x40007000), %o3
400071ac: 40 00 19 39 call 4000d690 <_POSIX_Timer_Insert_helper>
400071b0: 96 12 e1 4c or %o3, 0x14c, %o3 ! 4000714c <_POSIX_Timer_TSR>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
400071b4: 80 8a 20 ff btst 0xff, %o0
400071b8: 02 bf ff f6 be 40007190 <_POSIX_Timer_TSR+0x44> <== NEVER TAKEN
400071bc: 90 07 bf f8 add %fp, -8, %o0
400071c0: 13 10 00 7e sethi %hi(0x4001f800), %o1
400071c4: 40 00 06 3b call 40008ab0 <_TOD_Get_with_nanoseconds>
400071c8: 92 12 61 58 or %o1, 0x158, %o1 ! 4001f958 <_TOD>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
400071cc: 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);
400071d0: 94 10 20 00 clr %o2
400071d4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400071d8: 90 10 00 1c mov %i4, %o0
400071dc: 96 12 e2 00 or %o3, 0x200, %o3
400071e0: 40 00 4a 34 call 40019ab0 <__divdi3>
400071e4: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
400071e8: 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);
400071ec: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
400071f0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400071f4: 90 10 00 1c mov %i4, %o0
400071f8: 96 12 e2 00 or %o3, 0x200, %o3
400071fc: 40 00 4b 18 call 40019e5c <__moddi3>
40007200: 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;
40007204: 82 10 20 03 mov 3, %g1
40007208: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
4000720c: 10 bf ff dd b 40007180 <_POSIX_Timer_TSR+0x34>
40007210: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
4000efd8 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4000efd8: 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,
4000efdc: 98 10 20 01 mov 1, %o4
4000efe0: 90 10 00 18 mov %i0, %o0
4000efe4: 92 10 00 19 mov %i1, %o1
4000efe8: 94 07 bf cc add %fp, -52, %o2
4000efec: 40 00 00 2e call 4000f0a4 <_POSIX_signals_Clear_signals>
4000eff0: 96 10 00 1a mov %i2, %o3
4000eff4: 80 8a 20 ff btst 0xff, %o0
4000eff8: 02 80 00 23 be 4000f084 <_POSIX_signals_Check_signal+0xac>
4000effc: 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 )
4000f000: 85 2e 60 02 sll %i1, 2, %g2
4000f004: 37 10 00 7d sethi %hi(0x4001f400), %i3
4000f008: b9 2e 60 04 sll %i1, 4, %i4
4000f00c: b6 16 e0 30 or %i3, 0x30, %i3
4000f010: b8 27 00 02 sub %i4, %g2, %i4
4000f014: 84 06 c0 1c add %i3, %i4, %g2
4000f018: fa 00 a0 08 ld [ %g2 + 8 ], %i5
4000f01c: 80 a7 60 01 cmp %i5, 1
4000f020: 02 80 00 19 be 4000f084 <_POSIX_signals_Check_signal+0xac><== NEVER TAKEN
4000f024: 21 10 00 7c sethi %hi(0x4001f000), %l0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
4000f028: f4 06 20 d0 ld [ %i0 + 0xd0 ], %i2
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4000f02c: 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,
4000f030: a0 14 23 d0 or %l0, 0x3d0, %l0
4000f034: 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;
4000f038: 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,
4000f03c: 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;
4000f040: 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,
4000f044: 92 02 60 20 add %o1, 0x20, %o1
4000f048: 40 00 04 0f call 40010084 <memcpy>
4000f04c: 94 10 20 28 mov 0x28, %o2
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
4000f050: c2 06 c0 1c ld [ %i3 + %i4 ], %g1
4000f054: 80 a0 60 02 cmp %g1, 2
4000f058: 02 80 00 0e be 4000f090 <_POSIX_signals_Check_signal+0xb8>
4000f05c: 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 );
4000f060: 9f c7 40 00 call %i5
4000f064: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
4000f068: d0 04 20 10 ld [ %l0 + 0x10 ], %o0
4000f06c: 92 07 bf d8 add %fp, -40, %o1
4000f070: 90 02 20 20 add %o0, 0x20, %o0
4000f074: 40 00 04 04 call 40010084 <memcpy>
4000f078: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4000f07c: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
4000f080: f4 26 20 d0 st %i2, [ %i0 + 0xd0 ]
return true;
}
4000f084: b0 08 60 01 and %g1, 1, %i0
4000f088: 81 c7 e0 08 ret
4000f08c: 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)(
4000f090: 92 07 bf cc add %fp, -52, %o1
4000f094: 9f c7 40 00 call %i5
4000f098: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4000f09c: 10 bf ff f4 b 4000f06c <_POSIX_signals_Check_signal+0x94>
4000f0a0: d0 04 20 10 ld [ %l0 + 0x10 ], %o0
4000f698 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
4000f698: 9d e3 bf a0 save %sp, -96, %sp
4000f69c: 84 10 20 01 mov 1, %g2
4000f6a0: 82 06 3f ff add %i0, -1, %g1
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4000f6a4: 7f ff ca 80 call 400020a4 <sparc_disable_interrupts>
4000f6a8: bb 28 80 01 sll %g2, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4000f6ac: 05 10 00 7d sethi %hi(0x4001f400), %g2
4000f6b0: 83 2e 20 02 sll %i0, 2, %g1
4000f6b4: 84 10 a0 30 or %g2, 0x30, %g2
4000f6b8: b1 2e 20 04 sll %i0, 4, %i0
4000f6bc: 82 26 00 01 sub %i0, %g1, %g1
4000f6c0: c4 00 80 01 ld [ %g2 + %g1 ], %g2
4000f6c4: 80 a0 a0 02 cmp %g2, 2
4000f6c8: 02 80 00 08 be 4000f6e8 <_POSIX_signals_Clear_process_signals+0x50>
4000f6cc: 31 10 00 7d sethi %hi(0x4001f400), %i0
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4000f6d0: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000f6d4: c4 00 62 24 ld [ %g1 + 0x224 ], %g2 ! 4001f624 <_POSIX_signals_Pending>
4000f6d8: ba 28 80 1d andn %g2, %i5, %i5
4000f6dc: fa 20 62 24 st %i5, [ %g1 + 0x224 ]
}
_ISR_Enable( level );
4000f6e0: 7f ff ca 75 call 400020b4 <sparc_enable_interrupts>
4000f6e4: 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 ] ) )
4000f6e8: b0 16 22 28 or %i0, 0x228, %i0
4000f6ec: c4 00 40 18 ld [ %g1 + %i0 ], %g2
4000f6f0: 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 );
4000f6f4: b0 06 20 04 add %i0, 4, %i0
4000f6f8: 80 a0 80 18 cmp %g2, %i0
4000f6fc: 02 bf ff f6 be 4000f6d4 <_POSIX_signals_Clear_process_signals+0x3c><== ALWAYS TAKEN
4000f700: 03 10 00 7d sethi %hi(0x4001f400), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
4000f704: 7f ff ca 6c call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
4000f708: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40007cc0 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40007cc0: 82 10 20 1b mov 0x1b, %g1
40007cc4: 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(
40007cc8: 84 00 7f ff add %g1, -1, %g2
40007ccc: 85 28 c0 02 sll %g3, %g2, %g2
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
40007cd0: 80 88 80 08 btst %g2, %o0
40007cd4: 12 80 00 11 bne 40007d18 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
40007cd8: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40007cdc: 82 00 60 01 inc %g1
40007ce0: 80 a0 60 20 cmp %g1, 0x20
40007ce4: 12 bf ff fa bne 40007ccc <_POSIX_signals_Get_lowest+0xc>
40007ce8: 84 00 7f ff add %g1, -1, %g2
40007cec: 82 10 20 01 mov 1, %g1
40007cf0: 10 80 00 05 b 40007d04 <_POSIX_signals_Get_lowest+0x44>
40007cf4: 86 10 20 01 mov 1, %g3
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
40007cf8: 80 a0 60 1b cmp %g1, 0x1b
40007cfc: 02 80 00 07 be 40007d18 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
40007d00: 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(
40007d04: 84 00 7f ff add %g1, -1, %g2
40007d08: 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 ) ) {
40007d0c: 80 88 80 08 btst %g2, %o0
40007d10: 22 bf ff fa be,a 40007cf8 <_POSIX_signals_Get_lowest+0x38>
40007d14: 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;
}
40007d18: 81 c3 e0 08 retl
40007d1c: 90 10 00 01 mov %g1, %o0
4000c81c <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
4000c81c: 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;
4000c820: 35 10 00 7c sethi %hi(0x4001f000), %i2
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000c824: 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;
4000c828: b4 16 a3 d0 or %i2, 0x3d0, %i2
4000c82c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
4000c830: 80 a7 20 00 cmp %i4, 0
4000c834: 02 80 00 34 be 4000c904 <_POSIX_signals_Post_switch_hook+0xe8><== NEVER TAKEN
4000c838: 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 );
4000c83c: 7f ff d6 1a call 400020a4 <sparc_disable_interrupts>
4000c840: 37 10 00 7d sethi %hi(0x4001f400), %i3
4000c844: b6 16 e2 24 or %i3, 0x224, %i3 ! 4001f624 <_POSIX_signals_Pending>
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000c848: c6 06 c0 00 ld [ %i3 ], %g3
4000c84c: 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 &
4000c850: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000c854: 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 &
4000c858: 80 a8 40 02 andncc %g1, %g2, %g0
4000c85c: 02 80 00 26 be 4000c8f4 <_POSIX_signals_Post_switch_hook+0xd8>
4000c860: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
4000c864: 7f ff d6 14 call 400020b4 <sparc_enable_interrupts>
4000c868: ba 10 20 1b mov 0x1b, %i5 ! 1b <PROM_START+0x1b>
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4000c86c: 92 10 00 1d mov %i5, %o1
4000c870: 94 10 20 00 clr %o2
4000c874: 40 00 09 d9 call 4000efd8 <_POSIX_signals_Check_signal>
4000c878: 90 10 00 1c mov %i4, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000c87c: 92 10 00 1d mov %i5, %o1
4000c880: 90 10 00 1c mov %i4, %o0
4000c884: 40 00 09 d5 call 4000efd8 <_POSIX_signals_Check_signal>
4000c888: 94 10 20 01 mov 1, %o2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4000c88c: ba 07 60 01 inc %i5
4000c890: 80 a7 60 20 cmp %i5, 0x20
4000c894: 12 bf ff f7 bne 4000c870 <_POSIX_signals_Post_switch_hook+0x54>
4000c898: 92 10 00 1d mov %i5, %o1
4000c89c: 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 );
4000c8a0: 92 10 00 1d mov %i5, %o1
4000c8a4: 94 10 20 00 clr %o2
4000c8a8: 40 00 09 cc call 4000efd8 <_POSIX_signals_Check_signal>
4000c8ac: 90 10 00 1c mov %i4, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000c8b0: 92 10 00 1d mov %i5, %o1
4000c8b4: 90 10 00 1c mov %i4, %o0
4000c8b8: 40 00 09 c8 call 4000efd8 <_POSIX_signals_Check_signal>
4000c8bc: 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++ ) {
4000c8c0: ba 07 60 01 inc %i5
4000c8c4: 80 a7 60 1b cmp %i5, 0x1b
4000c8c8: 12 bf ff f7 bne 4000c8a4 <_POSIX_signals_Post_switch_hook+0x88>
4000c8cc: 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 );
4000c8d0: 7f ff d5 f5 call 400020a4 <sparc_disable_interrupts>
4000c8d4: 01 00 00 00 nop
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000c8d8: c6 06 c0 00 ld [ %i3 ], %g3
4000c8dc: 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 &
4000c8e0: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000c8e4: 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 &
4000c8e8: 80 a8 40 02 andncc %g1, %g2, %g0
4000c8ec: 12 bf ff de bne 4000c864 <_POSIX_signals_Post_switch_hook+0x48><== NEVER TAKEN
4000c8f0: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
4000c8f4: 7f ff d5 f0 call 400020b4 <sparc_enable_interrupts>
4000c8f8: 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;
4000c8fc: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000c900: f2 20 60 34 st %i1, [ %g1 + 0x34 ]
4000c904: 81 c7 e0 08 ret
4000c908: 81 e8 00 00 restore
4001bcf8 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
4001bcf8: 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 ) ) {
4001bcfc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001bd00: 05 04 00 20 sethi %hi(0x10008000), %g2
4001bd04: 88 10 20 01 mov 1, %g4
4001bd08: 86 06 7f ff add %i1, -1, %g3
4001bd0c: 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 ];
4001bd10: 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 ) ) {
4001bd14: 80 a7 40 02 cmp %i5, %g2
4001bd18: 02 80 00 2c be 4001bdc8 <_POSIX_signals_Unblock_thread+0xd0>
4001bd1c: 87 29 00 03 sll %g4, %g3, %g3
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
4001bd20: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
4001bd24: 80 a8 c0 02 andncc %g3, %g2, %g0
4001bd28: 02 80 00 24 be 4001bdb8 <_POSIX_signals_Unblock_thread+0xc0>
4001bd2c: 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 ) ) {
4001bd30: 80 88 40 02 btst %g1, %g2
4001bd34: 02 80 00 15 be 4001bd88 <_POSIX_signals_Unblock_thread+0x90>
4001bd38: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
4001bd3c: 84 10 20 04 mov 4, %g2
4001bd40: 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);
4001bd44: 05 00 00 ef sethi %hi(0x3bc00), %g2
4001bd48: 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) )
4001bd4c: 80 88 40 02 btst %g1, %g2
4001bd50: 12 80 00 38 bne 4001be30 <_POSIX_signals_Unblock_thread+0x138>
4001bd54: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
4001bd58: 22 80 00 19 be,a 4001bdbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001bd5c: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4001bd60: 7f ff bb f5 call 4000ad34 <_Watchdog_Remove>
4001bd64: 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 );
4001bd68: 90 10 00 18 mov %i0, %o0
4001bd6c: 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;
4001bd70: b0 10 20 00 clr %i0
4001bd74: 7f ff b7 68 call 40009b14 <_Thread_Clear_state>
4001bd78: 92 12 63 f8 or %o1, 0x3f8, %o1
4001bd7c: b0 0e 20 01 and %i0, 1, %i0
4001bd80: 81 c7 e0 08 ret
4001bd84: 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 ) {
4001bd88: 32 80 00 0d bne,a 4001bdbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001bd8c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001bd90: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001bd94: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 4001f3d0 <_Per_CPU_Information>
4001bd98: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001bd9c: 80 a0 a0 00 cmp %g2, 0
4001bda0: 22 80 00 07 be,a 4001bdbc <_POSIX_signals_Unblock_thread+0xc4>
4001bda4: b0 10 20 00 clr %i0
4001bda8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001bdac: 80 a6 00 02 cmp %i0, %g2
4001bdb0: 22 80 00 02 be,a 4001bdb8 <_POSIX_signals_Unblock_thread+0xc0><== ALWAYS TAKEN
4001bdb4: c8 28 60 0c stb %g4, [ %g1 + 0xc ]
_Thread_Dispatch_necessary = true;
}
}
return false;
4001bdb8: b0 10 20 00 clr %i0
}
4001bdbc: b0 0e 20 01 and %i0, 1, %i0
4001bdc0: 81 c7 e0 08 ret
4001bdc4: 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) ) {
4001bdc8: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4001bdcc: 80 88 c0 01 btst %g3, %g1
4001bdd0: 22 80 00 13 be,a 4001be1c <_POSIX_signals_Unblock_thread+0x124>
4001bdd4: c2 07 20 d0 ld [ %i4 + 0xd0 ], %g1
the_thread->Wait.return_code = EINTR;
4001bdd8: 82 10 20 04 mov 4, %g1
4001bddc: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
4001bde0: 80 a6 a0 00 cmp %i2, 0
4001bde4: 02 80 00 19 be 4001be48 <_POSIX_signals_Unblock_thread+0x150>
4001bde8: 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;
4001bdec: c4 06 80 00 ld [ %i2 ], %g2
4001bdf0: c4 20 40 00 st %g2, [ %g1 ]
4001bdf4: c4 06 a0 04 ld [ %i2 + 4 ], %g2
4001bdf8: c4 20 60 04 st %g2, [ %g1 + 4 ]
4001bdfc: c4 06 a0 08 ld [ %i2 + 8 ], %g2
4001be00: c4 20 60 08 st %g2, [ %g1 + 8 ]
}
_Thread_queue_Extract_with_proxy( the_thread );
4001be04: 90 10 00 18 mov %i0, %o0
4001be08: 7f ff ba 19 call 4000a66c <_Thread_queue_Extract_with_proxy>
4001be0c: b0 10 20 01 mov 1, %i0
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
4001be10: b0 0e 20 01 and %i0, 1, %i0
4001be14: 81 c7 e0 08 ret
4001be18: 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) ) {
4001be1c: 80 a8 c0 01 andncc %g3, %g1, %g0
4001be20: 32 bf ff ef bne,a 4001bddc <_POSIX_signals_Unblock_thread+0xe4>
4001be24: 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;
4001be28: 10 bf ff e5 b 4001bdbc <_POSIX_signals_Unblock_thread+0xc4>
4001be2c: 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 );
4001be30: 90 10 00 18 mov %i0, %o0
4001be34: 7f ff ba 0e call 4000a66c <_Thread_queue_Extract_with_proxy>
4001be38: b0 10 20 00 clr %i0
4001be3c: b0 0e 20 01 and %i0, 1, %i0
4001be40: 81 c7 e0 08 ret
4001be44: 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;
4001be48: 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;
4001be4c: f2 20 40 00 st %i1, [ %g1 ]
the_info->si_code = SI_USER;
4001be50: c4 20 60 04 st %g2, [ %g1 + 4 ]
the_info->si_value.sival_int = 0;
4001be54: 10 bf ff ec b 4001be04 <_POSIX_signals_Unblock_thread+0x10c>
4001be58: c0 20 60 08 clr [ %g1 + 8 ]
40009df4 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
40009df4: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
40009df8: 80 a6 60 00 cmp %i1, 0
40009dfc: 02 80 00 4c be 40009f2c <_RBTree_Extract_unprotected+0x138>
40009e00: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
40009e04: c2 06 20 08 ld [ %i0 + 8 ], %g1
40009e08: 80 a0 40 19 cmp %g1, %i1
40009e0c: 02 80 00 56 be 40009f64 <_RBTree_Extract_unprotected+0x170>
40009e10: 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]) {
40009e14: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40009e18: 80 a0 40 19 cmp %g1, %i1
40009e1c: 02 80 00 56 be 40009f74 <_RBTree_Extract_unprotected+0x180>
40009e20: 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]) {
40009e24: fa 06 60 04 ld [ %i1 + 4 ], %i5
40009e28: 80 a7 60 00 cmp %i5, 0
40009e2c: 22 80 00 5a be,a 40009f94 <_RBTree_Extract_unprotected+0x1a0>
40009e30: f8 06 60 08 ld [ %i1 + 8 ], %i4
40009e34: c2 06 60 08 ld [ %i1 + 8 ], %g1
40009e38: 80 a0 60 00 cmp %g1, 0
40009e3c: 32 80 00 05 bne,a 40009e50 <_RBTree_Extract_unprotected+0x5c>
40009e40: c2 07 60 08 ld [ %i5 + 8 ], %g1
40009e44: 10 80 00 3c b 40009f34 <_RBTree_Extract_unprotected+0x140>
40009e48: 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];
40009e4c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40009e50: 80 a0 60 00 cmp %g1, 0
40009e54: 32 bf ff fe bne,a 40009e4c <_RBTree_Extract_unprotected+0x58>
40009e58: 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];
40009e5c: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
40009e60: 80 a7 20 00 cmp %i4, 0
40009e64: 02 80 00 48 be 40009f84 <_RBTree_Extract_unprotected+0x190>
40009e68: 01 00 00 00 nop
leaf->parent = target->parent;
40009e6c: c2 07 40 00 ld [ %i5 ], %g1
40009e70: 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];
40009e74: 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];
40009e78: 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];
40009e7c: 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;
40009e80: c6 07 60 0c ld [ %i5 + 0xc ], %g3
dir = target != target->parent->child[0];
40009e84: 88 1f 40 04 xor %i5, %g4, %g4
40009e88: 80 a0 00 04 cmp %g0, %g4
40009e8c: 88 40 20 00 addx %g0, 0, %g4
target->parent->child[dir] = leaf;
40009e90: 89 29 20 02 sll %g4, 2, %g4
40009e94: 84 00 80 04 add %g2, %g4, %g2
40009e98: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
40009e9c: c4 00 60 04 ld [ %g1 + 4 ], %g2
40009ea0: 84 18 80 19 xor %g2, %i1, %g2
40009ea4: 80 a0 00 02 cmp %g0, %g2
40009ea8: 84 40 20 00 addx %g0, 0, %g2
the_node->parent->child[dir] = target;
40009eac: 85 28 a0 02 sll %g2, 2, %g2
40009eb0: 82 00 40 02 add %g1, %g2, %g1
40009eb4: 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];
40009eb8: c2 06 60 08 ld [ %i1 + 8 ], %g1
40009ebc: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
40009ec0: c2 06 60 08 ld [ %i1 + 8 ], %g1
40009ec4: 80 a0 60 00 cmp %g1, 0
40009ec8: 32 80 00 02 bne,a 40009ed0 <_RBTree_Extract_unprotected+0xdc><== ALWAYS TAKEN
40009ecc: fa 20 40 00 st %i5, [ %g1 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
40009ed0: c2 06 60 04 ld [ %i1 + 4 ], %g1
40009ed4: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
40009ed8: c2 06 60 04 ld [ %i1 + 4 ], %g1
40009edc: 80 a0 60 00 cmp %g1, 0
40009ee0: 32 80 00 02 bne,a 40009ee8 <_RBTree_Extract_unprotected+0xf4>
40009ee4: 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;
40009ee8: c4 06 40 00 ld [ %i1 ], %g2
target->color = the_node->color;
40009eec: 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;
40009ef0: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
40009ef4: 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 */
40009ef8: 80 a0 e0 00 cmp %g3, 0
40009efc: 32 80 00 06 bne,a 40009f14 <_RBTree_Extract_unprotected+0x120>
40009f00: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
40009f04: 80 a7 20 00 cmp %i4, 0
40009f08: 32 80 00 02 bne,a 40009f10 <_RBTree_Extract_unprotected+0x11c>
40009f0c: 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;
40009f10: 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;
40009f14: c0 26 60 08 clr [ %i1 + 8 ]
40009f18: c0 26 60 04 clr [ %i1 + 4 ]
40009f1c: 80 a0 60 00 cmp %g1, 0
40009f20: 02 80 00 03 be 40009f2c <_RBTree_Extract_unprotected+0x138>
40009f24: c0 26 40 00 clr [ %i1 ]
40009f28: c0 20 60 0c clr [ %g1 + 0xc ]
40009f2c: 81 c7 e0 08 ret
40009f30: 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;
40009f34: c2 06 40 00 ld [ %i1 ], %g1
40009f38: 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];
40009f3c: 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;
40009f40: c6 06 60 0c ld [ %i1 + 0xc ], %g3
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
40009f44: c4 00 60 04 ld [ %g1 + 4 ], %g2
40009f48: 84 18 80 19 xor %g2, %i1, %g2
40009f4c: 80 a0 00 02 cmp %g0, %g2
40009f50: 84 40 20 00 addx %g0, 0, %g2
the_node->parent->child[dir] = leaf;
40009f54: 85 28 a0 02 sll %g2, 2, %g2
40009f58: 82 00 40 02 add %g1, %g2, %g1
40009f5c: 10 bf ff e7 b 40009ef8 <_RBTree_Extract_unprotected+0x104>
40009f60: 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 );
40009f64: 40 00 00 eb call 4000a310 <_RBTree_Next_unprotected>
40009f68: 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;
40009f6c: 10 bf ff aa b 40009e14 <_RBTree_Extract_unprotected+0x20>
40009f70: 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 );
40009f74: 40 00 00 e7 call 4000a310 <_RBTree_Next_unprotected>
40009f78: 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;
40009f7c: 10 bf ff aa b 40009e24 <_RBTree_Extract_unprotected+0x30>
40009f80: 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);
40009f84: 7f ff fe d3 call 40009ad0 <_RBTree_Extract_validate_unprotected>
40009f88: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
40009f8c: 10 bf ff bb b 40009e78 <_RBTree_Extract_unprotected+0x84>
40009f90: 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 ) {
40009f94: 80 a7 20 00 cmp %i4, 0
40009f98: 32 bf ff e8 bne,a 40009f38 <_RBTree_Extract_unprotected+0x144>
40009f9c: 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);
40009fa0: 7f ff fe cc call 40009ad0 <_RBTree_Extract_validate_unprotected>
40009fa4: 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];
40009fa8: 10 bf ff e6 b 40009f40 <_RBTree_Extract_unprotected+0x14c>
40009fac: c2 06 40 00 ld [ %i1 ], %g1
40009ad0 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
40009ad0: c2 02 00 00 ld [ %o0 ], %g1
if(!parent->parent) return;
40009ad4: c4 00 40 00 ld [ %g1 ], %g2
40009ad8: 80 a0 a0 00 cmp %g2, 0
40009adc: 02 80 00 3f be 40009bd8 <_RBTree_Extract_validate_unprotected+0x108>
40009ae0: 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])
40009ae4: c4 00 60 04 ld [ %g1 + 4 ], %g2
40009ae8: 80 a2 00 02 cmp %o0, %g2
40009aec: 22 80 00 02 be,a 40009af4 <_RBTree_Extract_validate_unprotected+0x24>
40009af0: 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);
40009af4: c6 02 20 0c ld [ %o0 + 0xc ], %g3
40009af8: 80 a0 e0 01 cmp %g3, 1
40009afc: 02 80 00 32 be 40009bc4 <_RBTree_Extract_validate_unprotected+0xf4>
40009b00: 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) {
40009b04: c6 00 40 00 ld [ %g1 ], %g3
40009b08: 80 a0 e0 00 cmp %g3, 0
40009b0c: 02 80 00 2e be 40009bc4 <_RBTree_Extract_validate_unprotected+0xf4>
40009b10: 80 a0 a0 00 cmp %g2, 0
40009b14: 22 80 00 07 be,a 40009b30 <_RBTree_Extract_validate_unprotected+0x60><== NEVER TAKEN
40009b18: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED
40009b1c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
40009b20: 80 a1 20 01 cmp %g4, 1
40009b24: 22 80 00 63 be,a 40009cb0 <_RBTree_Extract_validate_unprotected+0x1e0>
40009b28: 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]) &&
40009b2c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
40009b30: 80 a0 e0 00 cmp %g3, 0
40009b34: 22 80 00 07 be,a 40009b50 <_RBTree_Extract_validate_unprotected+0x80>
40009b38: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40009b3c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
40009b40: 80 a0 e0 01 cmp %g3, 1
40009b44: 22 80 00 29 be,a 40009be8 <_RBTree_Extract_validate_unprotected+0x118>
40009b48: c6 00 60 04 ld [ %g1 + 4 ], %g3
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
40009b4c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40009b50: 80 a0 e0 00 cmp %g3, 0
40009b54: 22 80 00 07 be,a 40009b70 <_RBTree_Extract_validate_unprotected+0xa0>
40009b58: da 20 a0 0c st %o5, [ %g2 + 0xc ]
40009b5c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
40009b60: 80 a0 e0 01 cmp %g3, 1
40009b64: 22 80 00 21 be,a 40009be8 <_RBTree_Extract_validate_unprotected+0x118>
40009b68: c6 00 60 04 ld [ %g1 + 4 ], %g3
sibling->color = RBT_RED;
40009b6c: da 20 a0 0c st %o5, [ %g2 + 0xc ]
40009b70: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40009b74: 80 a0 a0 01 cmp %g2, 1
40009b78: 22 80 00 99 be,a 40009ddc <_RBTree_Extract_validate_unprotected+0x30c>
40009b7c: 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;
40009b80: 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;
40009b84: 80 a0 e0 00 cmp %g3, 0
40009b88: 02 80 00 6c be 40009d38 <_RBTree_Extract_validate_unprotected+0x268><== NEVER TAKEN
40009b8c: 90 10 00 01 mov %g1, %o0
if(!(the_node->parent->parent)) return NULL;
40009b90: c4 00 c0 00 ld [ %g3 ], %g2
40009b94: 80 a0 a0 00 cmp %g2, 0
40009b98: 02 80 00 69 be 40009d3c <_RBTree_Extract_validate_unprotected+0x26c>
40009b9c: 84 10 20 00 clr %g2
if(the_node == the_node->parent->child[RBT_LEFT])
40009ba0: c4 00 e0 04 ld [ %g3 + 4 ], %g2
40009ba4: 80 a0 40 02 cmp %g1, %g2
40009ba8: 22 80 00 0e be,a 40009be0 <_RBTree_Extract_validate_unprotected+0x110>
40009bac: 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;
40009bb0: 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);
40009bb4: c6 02 20 0c ld [ %o0 + 0xc ], %g3
40009bb8: 80 a0 e0 01 cmp %g3, 1
40009bbc: 32 bf ff d3 bne,a 40009b08 <_RBTree_Extract_validate_unprotected+0x38><== ALWAYS TAKEN
40009bc0: 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;
40009bc4: c2 02 00 00 ld [ %o0 ], %g1
40009bc8: c2 00 40 00 ld [ %g1 ], %g1
40009bcc: 80 a0 60 00 cmp %g1, 0
40009bd0: 02 80 00 5f be 40009d4c <_RBTree_Extract_validate_unprotected+0x27c>
40009bd4: 01 00 00 00 nop
40009bd8: 81 c3 e0 08 retl
40009bdc: 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;
40009be0: 10 bf ff f5 b 40009bb4 <_RBTree_Extract_validate_unprotected+0xe4>
40009be4: 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];
40009be8: 86 1a 00 03 xor %o0, %g3, %g3
40009bec: 80 a0 00 03 cmp %g0, %g3
40009bf0: 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);
40009bf4: 86 1b 60 01 xor %o5, 1, %g3
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
40009bf8: 87 28 e0 02 sll %g3, 2, %g3
40009bfc: 88 00 80 03 add %g2, %g3, %g4
40009c00: 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);
40009c04: 80 a1 20 00 cmp %g4, 0
40009c08: 22 80 00 07 be,a 40009c24 <_RBTree_Extract_validate_unprotected+0x154>
40009c0c: 9b 2b 60 02 sll %o5, 2, %o5
40009c10: d8 01 20 0c ld [ %g4 + 0xc ], %o4
40009c14: 80 a3 20 01 cmp %o4, 1
40009c18: 22 80 00 4f be,a 40009d54 <_RBTree_Extract_validate_unprotected+0x284>
40009c1c: d6 00 60 0c ld [ %g1 + 0xc ], %o3
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
40009c20: 9b 2b 60 02 sll %o5, 2, %o5
40009c24: 98 00 80 0d add %g2, %o5, %o4
40009c28: 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;
40009c2c: 96 10 20 01 mov 1, %o3
40009c30: 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;
40009c34: 80 a1 20 00 cmp %g4, 0
40009c38: 02 80 00 15 be 40009c8c <_RBTree_Extract_validate_unprotected+0x1bc><== NEVER TAKEN
40009c3c: 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];
40009c40: 96 01 00 03 add %g4, %g3, %o3
40009c44: d4 02 e0 04 ld [ %o3 + 4 ], %o2
40009c48: d4 23 20 04 st %o2, [ %o4 + 4 ]
if (c->child[dir])
40009c4c: d8 02 e0 04 ld [ %o3 + 4 ], %o4
40009c50: 80 a3 20 00 cmp %o4, 0
40009c54: 32 80 00 02 bne,a 40009c5c <_RBTree_Extract_validate_unprotected+0x18c>
40009c58: 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;
40009c5c: 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;
40009c60: 96 01 00 03 add %g4, %g3, %o3
40009c64: c4 22 e0 04 st %g2, [ %o3 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009c68: d6 03 20 04 ld [ %o4 + 4 ], %o3
c->parent = the_node->parent;
40009c6c: 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;
40009c70: 96 18 80 0b xor %g2, %o3, %o3
c->parent = the_node->parent;
the_node->parent = c;
40009c74: 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;
40009c78: 80 a0 00 0b cmp %g0, %o3
40009c7c: 84 40 20 00 addx %g0, 0, %g2
40009c80: 85 28 a0 02 sll %g2, 2, %g2
40009c84: 98 03 00 02 add %o4, %g2, %o4
40009c88: 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;
40009c8c: 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)];
40009c90: 84 00 40 03 add %g1, %g3, %g2
40009c94: c4 00 a0 04 ld [ %g2 + 4 ], %g2
}
sibling->color = parent->color;
40009c98: c8 20 a0 0c st %g4, [ %g2 + 0xc ]
40009c9c: 88 00 80 03 add %g2, %g3, %g4
40009ca0: c8 01 20 04 ld [ %g4 + 4 ], %g4
parent->color = RBT_BLACK;
40009ca4: c0 20 60 0c clr [ %g1 + 0xc ]
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
40009ca8: 10 80 00 33 b 40009d74 <_RBTree_Extract_validate_unprotected+0x2a4>
40009cac: 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;
40009cb0: c8 20 60 0c st %g4, [ %g1 + 0xc ]
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
40009cb4: 88 1b 00 08 xor %o4, %o0, %g4
40009cb8: 80 a0 00 04 cmp %g0, %g4
40009cbc: 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);
40009cc0: 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;
40009cc4: 97 2a e0 02 sll %o3, 2, %o3
40009cc8: 98 00 40 0b add %g1, %o3, %o4
40009ccc: c8 03 20 04 ld [ %o4 + 4 ], %g4
40009cd0: 80 a1 20 00 cmp %g4, 0
40009cd4: 02 80 00 1c be 40009d44 <_RBTree_Extract_validate_unprotected+0x274><== NEVER TAKEN
40009cd8: 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];
40009cdc: 95 2a a0 02 sll %o2, 2, %o2
40009ce0: 84 01 00 0a add %g4, %o2, %g2
40009ce4: d2 00 a0 04 ld [ %g2 + 4 ], %o1
40009ce8: d2 23 20 04 st %o1, [ %o4 + 4 ]
if (c->child[dir])
40009cec: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40009cf0: 80 a0 a0 00 cmp %g2, 0
40009cf4: 02 80 00 04 be 40009d04 <_RBTree_Extract_validate_unprotected+0x234><== NEVER TAKEN
40009cf8: 94 01 00 0a add %g4, %o2, %o2
c->child[dir]->parent = the_node;
40009cfc: c2 20 80 00 st %g1, [ %g2 ]
40009d00: c6 00 40 00 ld [ %g1 ], %g3
c->child[dir] = the_node;
40009d04: c2 22 a0 04 st %g1, [ %o2 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009d08: c4 00 e0 04 ld [ %g3 + 4 ], %g2
c->parent = the_node->parent;
40009d0c: 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;
40009d10: 84 18 40 02 xor %g1, %g2, %g2
40009d14: 80 a0 00 02 cmp %g0, %g2
40009d18: 84 40 20 00 addx %g0, 0, %g2
40009d1c: 85 28 a0 02 sll %g2, 2, %g2
40009d20: 96 00 40 0b add %g1, %o3, %o3
40009d24: 86 00 c0 02 add %g3, %g2, %g3
c->parent = the_node->parent;
the_node->parent = c;
40009d28: 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;
40009d2c: c8 20 e0 04 st %g4, [ %g3 + 4 ]
40009d30: 10 bf ff 7f b 40009b2c <_RBTree_Extract_validate_unprotected+0x5c>
40009d34: 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;
40009d38: 84 10 20 00 clr %g2 <== NOT EXECUTED
40009d3c: 10 bf ff 9e b 40009bb4 <_RBTree_Extract_validate_unprotected+0xe4>
40009d40: 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;
40009d44: 10 bf ff 7a b 40009b2c <_RBTree_Extract_validate_unprotected+0x5c><== NOT EXECUTED
40009d48: 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;
40009d4c: 81 c3 e0 08 retl
40009d50: c0 22 20 0c clr [ %o0 + 0xc ]
40009d54: 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;
40009d58: d6 20 a0 0c st %o3, [ %g2 + 0xc ]
parent->color = RBT_BLACK;
40009d5c: c0 20 60 0c clr [ %g1 + 0xc ]
40009d60: c4 03 20 04 ld [ %o4 + 4 ], %g2
40009d64: 80 a0 a0 00 cmp %g2, 0
40009d68: 02 bf ff 97 be 40009bc4 <_RBTree_Extract_validate_unprotected+0xf4><== NEVER TAKEN
40009d6c: c0 21 20 0c clr [ %g4 + 0xc ]
40009d70: 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];
40009d74: 88 00 80 0d add %g2, %o5, %g4
40009d78: d8 01 20 04 ld [ %g4 + 4 ], %o4
40009d7c: 86 00 40 03 add %g1, %g3, %g3
40009d80: d8 20 e0 04 st %o4, [ %g3 + 4 ]
if (c->child[dir])
40009d84: c6 01 20 04 ld [ %g4 + 4 ], %g3
40009d88: 80 a0 e0 00 cmp %g3, 0
40009d8c: 32 80 00 02 bne,a 40009d94 <_RBTree_Extract_validate_unprotected+0x2c4>
40009d90: 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;
40009d94: 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;
40009d98: 9a 00 80 0d add %g2, %o5, %o5
40009d9c: c2 23 60 04 st %g1, [ %o5 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009da0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
c->parent = the_node->parent;
40009da4: c6 20 80 00 st %g3, [ %g2 ]
the_node->parent = c;
40009da8: 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;
40009dac: 88 18 40 04 xor %g1, %g4, %g4
40009db0: 80 a0 00 04 cmp %g0, %g4
40009db4: 82 40 20 00 addx %g0, 0, %g1
40009db8: 83 28 60 02 sll %g1, 2, %g1
40009dbc: 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;
40009dc0: c2 02 00 00 ld [ %o0 ], %g1
40009dc4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
40009dc8: c2 00 40 00 ld [ %g1 ], %g1
40009dcc: 80 a0 60 00 cmp %g1, 0
40009dd0: 12 bf ff 82 bne 40009bd8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
40009dd4: 01 00 00 00 nop
40009dd8: 30 bf ff dd b,a 40009d4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
40009ddc: c2 02 00 00 ld [ %o0 ], %g1
40009de0: c2 00 40 00 ld [ %g1 ], %g1
40009de4: 80 a0 60 00 cmp %g1, 0
40009de8: 12 bf ff 7c bne 40009bd8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
40009dec: 01 00 00 00 nop
40009df0: 30 bf ff d7 b,a 40009d4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
4000aa6c <_RBTree_Find>:
RBTree_Node *_RBTree_Find(
RBTree_Control *the_rbtree,
RBTree_Node *search_node
)
{
4000aa6c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
4000aa70: 7f ff e3 50 call 400037b0 <sparc_disable_interrupts>
4000aa74: b8 10 00 18 mov %i0, %i4
4000aa78: 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;
4000aa7c: fa 06 20 04 ld [ %i0 + 4 ], %i5
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
4000aa80: 80 a7 60 00 cmp %i5, 0
4000aa84: 02 80 00 15 be 4000aad8 <_RBTree_Find+0x6c> <== NEVER TAKEN
4000aa88: b0 10 20 00 clr %i0
compare_result = the_rbtree->compare_function(the_node, iter_node);
4000aa8c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000aa90: 92 10 00 1d mov %i5, %o1
4000aa94: 9f c0 40 00 call %g1
4000aa98: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
4000aa9c: 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 ) ) {
4000aaa0: 80 a2 20 00 cmp %o0, 0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
4000aaa4: 82 20 40 08 sub %g1, %o0, %g1
4000aaa8: 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];
4000aaac: 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 ) ) {
4000aab0: 12 80 00 06 bne 4000aac8 <_RBTree_Find+0x5c>
4000aab4: 82 07 40 01 add %i5, %g1, %g1
found = iter_node;
if ( the_rbtree->is_unique )
4000aab8: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
4000aabc: 80 a0 a0 00 cmp %g2, 0
4000aac0: 12 80 00 0a bne 4000aae8 <_RBTree_Find+0x7c>
4000aac4: b0 10 00 1d mov %i5, %i0
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
4000aac8: 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) {
4000aacc: 80 a7 60 00 cmp %i5, 0
4000aad0: 32 bf ff f0 bne,a 4000aa90 <_RBTree_Find+0x24>
4000aad4: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
4000aad8: 7f ff e3 3a call 400037c0 <sparc_enable_interrupts>
4000aadc: 90 10 00 1b mov %i3, %o0
return return_node;
}
4000aae0: 81 c7 e0 08 ret
4000aae4: 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 );
4000aae8: 7f ff e3 36 call 400037c0 <sparc_enable_interrupts>
4000aaec: 90 10 00 1b mov %i3, %o0
return return_node;
}
4000aaf0: 81 c7 e0 08 ret
4000aaf4: 81 e8 00 00 restore
4000aed8 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
4000aed8: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
4000aedc: 80 a6 20 00 cmp %i0, 0
4000aee0: 02 80 00 0f be 4000af1c <_RBTree_Initialize+0x44> <== NEVER TAKEN
4000aee4: 80 a6 e0 00 cmp %i3, 0
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
4000aee8: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
4000aeec: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
4000aef0: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
4000aef4: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
4000aef8: 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-- ) {
4000aefc: 02 80 00 08 be 4000af1c <_RBTree_Initialize+0x44> <== NEVER TAKEN
4000af00: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
4000af04: 92 10 00 1a mov %i2, %o1
4000af08: 7f ff ff 0b call 4000ab34 <_RBTree_Insert_unprotected>
4000af0c: 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-- ) {
4000af10: b6 86 ff ff addcc %i3, -1, %i3
4000af14: 12 bf ff fc bne 4000af04 <_RBTree_Initialize+0x2c>
4000af18: b4 06 80 1c add %i2, %i4, %i2
4000af1c: 81 c7 e0 08 ret
4000af20: 81 e8 00 00 restore
40009fd4 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
40009fd4: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
40009fd8: 80 a6 60 00 cmp %i1, 0
40009fdc: 02 80 00 9c be 4000a24c <_RBTree_Insert_unprotected+0x278>
40009fe0: b8 10 00 18 mov %i0, %i4
RBTree_Node *iter_node = the_rbtree->root;
40009fe4: fa 06 20 04 ld [ %i0 + 4 ], %i5
int compare_result;
if (!iter_node) { /* special case: first node inserted */
40009fe8: 80 a7 60 00 cmp %i5, 0
40009fec: 32 80 00 05 bne,a 4000a000 <_RBTree_Insert_unprotected+0x2c>
40009ff0: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
the_node->color = RBT_BLACK;
40009ff4: 10 80 00 9a b 4000a25c <_RBTree_Insert_unprotected+0x288>
40009ff8: 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);
40009ffc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000a000: 92 10 00 1d mov %i5, %o1
4000a004: 9f c0 40 00 call %g1
4000a008: 90 10 00 19 mov %i1, %o0
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000a00c: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
4000a010: 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 ) )
4000a014: 80 a0 a0 00 cmp %g2, 0
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
4000a018: b7 36 e0 1f srl %i3, 0x1f, %i3
if (!iter_node->child[dir]) {
4000a01c: 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 ) )
4000a020: 02 80 00 05 be 4000a034 <_RBTree_Insert_unprotected+0x60>
4000a024: 82 07 40 01 add %i5, %g1, %g1
4000a028: 80 a2 20 00 cmp %o0, 0
4000a02c: 02 80 00 8a be 4000a254 <_RBTree_Insert_unprotected+0x280>
4000a030: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
4000a034: f0 00 60 04 ld [ %g1 + 4 ], %i0
4000a038: 80 a6 20 00 cmp %i0, 0
4000a03c: 32 bf ff f0 bne,a 40009ffc <_RBTree_Insert_unprotected+0x28>
4000a040: 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(
4000a044: 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];
4000a048: b4 06 e0 02 add %i3, 2, %i2
4000a04c: 87 2e a0 02 sll %i2, 2, %g3
4000a050: 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;
4000a054: c0 26 60 08 clr [ %i1 + 8 ]
4000a058: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
4000a05c: 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;
4000a060: 82 10 20 01 mov 1, %g1
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
4000a064: 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;
4000a068: 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(
4000a06c: 9f c0 80 00 call %g2
4000a070: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
4000a074: 80 a6 e0 00 cmp %i3, 0
4000a078: 12 80 00 10 bne 4000a0b8 <_RBTree_Insert_unprotected+0xe4>
4000a07c: 80 a2 20 00 cmp %o0, 0
4000a080: 06 80 00 10 bl 4000a0c0 <_RBTree_Insert_unprotected+0xec>
4000a084: b5 2e a0 02 sll %i2, 2, %i2
4000a088: 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;
4000a08c: 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;
4000a090: c4 00 40 00 ld [ %g1 ], %g2
4000a094: 86 90 a0 00 orcc %g2, 0, %g3
4000a098: 22 80 00 06 be,a 4000a0b0 <_RBTree_Insert_unprotected+0xdc>
4000a09c: 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);
4000a0a0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4000a0a4: 80 a1 20 01 cmp %g4, 1
4000a0a8: 22 80 00 08 be,a 4000a0c8 <_RBTree_Insert_unprotected+0xf4>
4000a0ac: f6 00 80 00 ld [ %g2 ], %i3
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
4000a0b0: 81 c7 e0 08 ret
4000a0b4: 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)) ) {
4000a0b8: 04 bf ff f4 ble 4000a088 <_RBTree_Insert_unprotected+0xb4>
4000a0bc: b5 2e a0 02 sll %i2, 2, %i2
the_rbtree->first[dir] = the_node;
4000a0c0: 10 bf ff f2 b 4000a088 <_RBTree_Insert_unprotected+0xb4>
4000a0c4: 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;
4000a0c8: 80 a6 e0 00 cmp %i3, 0
4000a0cc: 02 80 00 0c be 4000a0fc <_RBTree_Insert_unprotected+0x128><== NEVER TAKEN
4000a0d0: 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])
4000a0d4: 80 a1 00 01 cmp %g4, %g1
4000a0d8: 02 80 00 5b be 4000a244 <_RBTree_Insert_unprotected+0x270>
4000a0dc: 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);
4000a0e0: 80 a7 60 00 cmp %i5, 0
4000a0e4: 22 80 00 07 be,a 4000a100 <_RBTree_Insert_unprotected+0x12c>
4000a0e8: fa 00 60 04 ld [ %g1 + 4 ], %i5
4000a0ec: f8 07 60 0c ld [ %i5 + 0xc ], %i4
4000a0f0: 80 a7 20 01 cmp %i4, 1
4000a0f4: 22 80 00 4f be,a 4000a230 <_RBTree_Insert_unprotected+0x25c>
4000a0f8: 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];
4000a0fc: fa 00 60 04 ld [ %g1 + 4 ], %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
4000a100: 88 18 40 04 xor %g1, %g4, %g4
4000a104: 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];
4000a108: ba 1e 40 1d xor %i1, %i5, %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
4000a10c: 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];
4000a110: 80 a0 00 1d cmp %g0, %i5
4000a114: 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) {
4000a118: 80 a7 40 04 cmp %i5, %g4
4000a11c: 02 80 00 20 be 4000a19c <_RBTree_Insert_unprotected+0x1c8>
4000a120: 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);
4000a124: 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;
4000a128: b7 2e e0 02 sll %i3, 2, %i3
4000a12c: b6 00 40 1b add %g1, %i3, %i3
4000a130: fa 06 e0 04 ld [ %i3 + 4 ], %i5
4000a134: 80 a7 60 00 cmp %i5, 0
4000a138: 02 80 00 16 be 4000a190 <_RBTree_Insert_unprotected+0x1bc><== NEVER TAKEN
4000a13c: 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];
4000a140: 9e 07 40 1c add %i5, %i4, %o7
4000a144: da 03 e0 04 ld [ %o7 + 4 ], %o5
4000a148: da 26 e0 04 st %o5, [ %i3 + 4 ]
if (c->child[dir])
4000a14c: f6 03 e0 04 ld [ %o7 + 4 ], %i3
4000a150: 80 a6 e0 00 cmp %i3, 0
4000a154: 22 80 00 05 be,a 4000a168 <_RBTree_Insert_unprotected+0x194>
4000a158: b6 07 40 1c add %i5, %i4, %i3
c->child[dir]->parent = the_node;
4000a15c: c2 26 c0 00 st %g1, [ %i3 ]
4000a160: c4 00 40 00 ld [ %g1 ], %g2
c->child[dir] = the_node;
4000a164: b6 07 40 1c add %i5, %i4, %i3
4000a168: c2 26 e0 04 st %g1, [ %i3 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a16c: f6 00 a0 04 ld [ %g2 + 4 ], %i3
c->parent = the_node->parent;
4000a170: 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;
4000a174: b6 1e c0 01 xor %i3, %g1, %i3
c->parent = the_node->parent;
the_node->parent = c;
4000a178: 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;
4000a17c: 80 a0 00 1b cmp %g0, %i3
4000a180: 82 40 20 00 addx %g0, 0, %g1
4000a184: 83 28 60 02 sll %g1, 2, %g1
4000a188: 84 00 80 01 add %g2, %g1, %g2
4000a18c: fa 20 a0 04 st %i5, [ %g2 + 4 ]
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
4000a190: b2 06 40 1c add %i1, %i4, %i1
4000a194: f2 06 60 04 ld [ %i1 + 4 ], %i1
4000a198: c2 06 40 00 ld [ %i1 ], %g1
}
the_node->parent->color = RBT_BLACK;
4000a19c: 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));
4000a1a0: 88 26 80 04 sub %i2, %g4, %g4
4000a1a4: 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;
4000a1a8: bb 2f 60 02 sll %i5, 2, %i5
4000a1ac: ba 00 c0 1d add %g3, %i5, %i5
4000a1b0: c4 07 60 04 ld [ %i5 + 4 ], %g2
4000a1b4: 80 a0 a0 00 cmp %g2, 0
4000a1b8: 02 bf ff b6 be 4000a090 <_RBTree_Insert_unprotected+0xbc> <== NEVER TAKEN
4000a1bc: 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];
4000a1c0: 89 29 20 02 sll %g4, 2, %g4
4000a1c4: 82 00 80 04 add %g2, %g4, %g1
4000a1c8: f8 00 60 04 ld [ %g1 + 4 ], %i4
4000a1cc: f8 27 60 04 st %i4, [ %i5 + 4 ]
if (c->child[dir])
4000a1d0: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000a1d4: 80 a0 60 00 cmp %g1, 0
4000a1d8: 32 80 00 02 bne,a 4000a1e0 <_RBTree_Insert_unprotected+0x20c>
4000a1dc: 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;
4000a1e0: 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;
4000a1e4: 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;
4000a1e8: 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;
4000a1ec: c6 21 20 04 st %g3, [ %g4 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a1f0: c8 07 60 04 ld [ %i5 + 4 ], %g4
c->parent = the_node->parent;
the_node->parent = c;
4000a1f4: c4 20 c0 00 st %g2, [ %g3 ]
4000a1f8: 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;
4000a1fc: 86 18 c0 04 xor %g3, %g4, %g3
4000a200: 80 a0 00 03 cmp %g0, %g3
4000a204: 86 40 20 00 addx %g0, 0, %g3
4000a208: 87 28 e0 02 sll %g3, 2, %g3
4000a20c: ba 07 40 03 add %i5, %g3, %i5
4000a210: 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;
4000a214: c4 00 40 00 ld [ %g1 ], %g2
4000a218: 86 90 a0 00 orcc %g2, 0, %g3
4000a21c: 32 bf ff a2 bne,a 4000a0a4 <_RBTree_Insert_unprotected+0xd0><== ALWAYS TAKEN
4000a220: c8 00 60 0c ld [ %g1 + 0xc ], %g4
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4000a224: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
4000a228: 81 c7 e0 08 ret <== NOT EXECUTED
4000a22c: 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;
4000a230: c0 27 60 0c clr [ %i5 + 0xc ]
g->color = RBT_RED;
4000a234: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
4000a238: 82 10 00 1b mov %i3, %g1
4000a23c: 10 bf ff 95 b 4000a090 <_RBTree_Insert_unprotected+0xbc>
4000a240: 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];
4000a244: 10 bf ff a7 b 4000a0e0 <_RBTree_Insert_unprotected+0x10c>
4000a248: 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;
4000a24c: 81 c7 e0 08 ret
4000a250: 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 ) )
4000a254: 81 c7 e0 08 ret
4000a258: 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;
4000a25c: f2 26 20 04 st %i1, [ %i0 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
4000a260: f2 26 20 0c st %i1, [ %i0 + 0xc ]
4000a264: f2 26 20 08 st %i1, [ %i0 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
4000a268: f0 26 40 00 st %i0, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
4000a26c: c0 26 60 08 clr [ %i1 + 8 ]
4000a270: c0 26 60 04 clr [ %i1 + 4 ]
} /* while(iter_node) */
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
4000a274: 81 c7 e0 08 ret
4000a278: 91 e8 20 00 restore %g0, 0, %o0
4000a2ac <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
4000a2ac: 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);
4000a2b0: 80 a0 00 19 cmp %g0, %i1
4000a2b4: 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];
4000a2b8: 82 00 60 02 add %g1, 2, %g1
4000a2bc: 83 28 60 02 sll %g1, 2, %g1
4000a2c0: 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 ) {
4000a2c4: 80 a7 60 00 cmp %i5, 0
4000a2c8: 12 80 00 06 bne 4000a2e0 <_RBTree_Iterate_unprotected+0x34><== ALWAYS TAKEN
4000a2cc: 94 10 00 1b mov %i3, %o2
4000a2d0: 30 80 00 0e b,a 4000a308 <_RBTree_Iterate_unprotected+0x5c><== NOT EXECUTED
4000a2d4: 80 8f 20 ff btst 0xff, %i4
4000a2d8: 02 80 00 0c be 4000a308 <_RBTree_Iterate_unprotected+0x5c><== NEVER TAKEN
4000a2dc: 94 10 00 1b mov %i3, %o2
stop = (*visitor)( current, dir, visitor_arg );
4000a2e0: 90 10 00 1d mov %i5, %o0
4000a2e4: 9f c6 80 00 call %i2
4000a2e8: 92 10 00 19 mov %i1, %o1
current = _RBTree_Next_unprotected( current, dir );
4000a2ec: 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 );
4000a2f0: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
4000a2f4: 40 00 00 07 call 4000a310 <_RBTree_Next_unprotected>
4000a2f8: 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 ) {
4000a2fc: ba 92 20 00 orcc %o0, 0, %i5
4000a300: 12 bf ff f5 bne 4000a2d4 <_RBTree_Iterate_unprotected+0x28>
4000a304: b8 1f 20 01 xor %i4, 1, %i4
4000a308: 81 c7 e0 08 ret
4000a30c: 81 e8 00 00 restore
40008418 <_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 )
{
40008418: 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 ];
4000841c: fa 06 21 4c ld [ %i0 + 0x14c ], %i5
if ( !api )
40008420: 80 a7 60 00 cmp %i5, 0
40008424: 02 80 00 1e be 4000849c <_RTEMS_signal_Post_switch_hook+0x84><== NEVER TAKEN
40008428: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
4000842c: 7f ff ea c7 call 40002f48 <sparc_disable_interrupts>
40008430: 01 00 00 00 nop
signal_set = asr->signals_posted;
40008434: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
40008438: c0 27 60 14 clr [ %i5 + 0x14 ]
_ISR_Enable( level );
4000843c: 7f ff ea c7 call 40002f58 <sparc_enable_interrupts>
40008440: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
40008444: 80 a7 20 00 cmp %i4, 0
40008448: 32 80 00 04 bne,a 40008458 <_RTEMS_signal_Post_switch_hook+0x40>
4000844c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40008450: 81 c7 e0 08 ret
40008454: 81 e8 00 00 restore
return;
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008458: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
4000845c: 82 00 60 01 inc %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008460: 94 07 bf fc add %fp, -4, %o2
40008464: 37 00 00 3f sethi %hi(0xfc00), %i3
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
40008468: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000846c: 40 00 01 07 call 40008888 <rtems_task_mode>
40008470: 92 16 e3 ff or %i3, 0x3ff, %o1
(*asr->handler)( signal_set );
40008474: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40008478: 9f c0 40 00 call %g1
4000847c: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
40008480: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
40008484: 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;
40008488: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000848c: 92 16 e3 ff or %i3, 0x3ff, %o1
40008490: 94 07 bf fc add %fp, -4, %o2
40008494: 40 00 00 fd call 40008888 <rtems_task_mode>
40008498: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
4000849c: 81 c7 e0 08 ret
400084a0: 81 e8 00 00 restore
400077cc <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
400077cc: 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;
400077d0: 03 10 00 78 sethi %hi(0x4001e000), %g1
400077d4: 82 10 62 e4 or %g1, 0x2e4, %g1 ! 4001e2e4 <Configuration_RTEMS_API>
400077d8: 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 )
400077dc: 80 a7 60 00 cmp %i5, 0
400077e0: 02 80 00 18 be 40007840 <_RTEMS_tasks_Initialize_user_tasks_body+0x74>
400077e4: 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++ ) {
400077e8: 80 a6 e0 00 cmp %i3, 0
400077ec: 02 80 00 15 be 40007840 <_RTEMS_tasks_Initialize_user_tasks_body+0x74><== NEVER TAKEN
400077f0: b8 10 20 00 clr %i4
return_value = rtems_task_create(
400077f4: d4 07 60 04 ld [ %i5 + 4 ], %o2
400077f8: d0 07 40 00 ld [ %i5 ], %o0
400077fc: d2 07 60 08 ld [ %i5 + 8 ], %o1
40007800: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
40007804: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40007808: 7f ff ff 70 call 400075c8 <rtems_task_create>
4000780c: 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 ) )
40007810: 94 92 20 00 orcc %o0, 0, %o2
40007814: 12 80 00 0d bne 40007848 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40007818: d0 07 bf fc ld [ %fp + -4 ], %o0
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
4000781c: d4 07 60 18 ld [ %i5 + 0x18 ], %o2
40007820: 40 00 00 0e call 40007858 <rtems_task_start>
40007824: 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 ) )
40007828: 94 92 20 00 orcc %o0, 0, %o2
4000782c: 12 80 00 07 bne 40007848 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40007830: b8 07 20 01 inc %i4
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
40007834: 80 a7 00 1b cmp %i4, %i3
40007838: 12 bf ff ef bne 400077f4 <_RTEMS_tasks_Initialize_user_tasks_body+0x28><== NEVER TAKEN
4000783c: ba 07 60 1c add %i5, 0x1c, %i5
40007840: 81 c7 e0 08 ret
40007844: 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 );
40007848: 90 10 20 01 mov 1, %o0
4000784c: 40 00 04 30 call 4000890c <_Internal_error_Occurred>
40007850: 92 10 20 01 mov 1, %o1
4000d020 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
4000d020: c2 02 21 58 ld [ %o0 + 0x158 ], %g1
while (tvp) {
4000d024: 80 a0 60 00 cmp %g1, 0
4000d028: 22 80 00 0c be,a 4000d058 <_RTEMS_tasks_Switch_extension+0x38>
4000d02c: c2 02 61 58 ld [ %o1 + 0x158 ], %g1
tvp->tval = *tvp->ptr;
4000d030: c4 00 60 04 ld [ %g1 + 4 ], %g2
*tvp->ptr = tvp->gval;
4000d034: c6 00 60 08 ld [ %g1 + 8 ], %g3
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
4000d038: c8 00 80 00 ld [ %g2 ], %g4
4000d03c: c8 20 60 0c st %g4, [ %g1 + 0xc ]
*tvp->ptr = tvp->gval;
4000d040: c6 20 80 00 st %g3, [ %g2 ]
tvp = (rtems_task_variable_t *)tvp->next;
4000d044: c2 00 40 00 ld [ %g1 ], %g1
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
4000d048: 80 a0 60 00 cmp %g1, 0
4000d04c: 32 bf ff fa bne,a 4000d034 <_RTEMS_tasks_Switch_extension+0x14><== NEVER TAKEN
4000d050: 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;
4000d054: c2 02 61 58 ld [ %o1 + 0x158 ], %g1
while (tvp) {
4000d058: 80 a0 60 00 cmp %g1, 0
4000d05c: 02 80 00 0d be 4000d090 <_RTEMS_tasks_Switch_extension+0x70>
4000d060: 01 00 00 00 nop
tvp->gval = *tvp->ptr;
4000d064: c4 00 60 04 ld [ %g1 + 4 ], %g2
*tvp->ptr = tvp->tval;
4000d068: 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;
4000d06c: c8 00 80 00 ld [ %g2 ], %g4
4000d070: c8 20 60 08 st %g4, [ %g1 + 8 ]
*tvp->ptr = tvp->tval;
4000d074: c6 20 80 00 st %g3, [ %g2 ]
tvp = (rtems_task_variable_t *)tvp->next;
4000d078: c2 00 40 00 ld [ %g1 ], %g1
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
4000d07c: 80 a0 60 00 cmp %g1, 0
4000d080: 32 bf ff fa bne,a 4000d068 <_RTEMS_tasks_Switch_extension+0x48><== NEVER TAKEN
4000d084: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
4000d088: 81 c3 e0 08 retl
4000d08c: 01 00 00 00 nop
4000d090: 81 c3 e0 08 retl
4003768c <_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
)
{
4003768c: 9d e3 bf 98 save %sp, -104, %sp
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40037690: 13 10 01 a0 sethi %hi(0x40068000), %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
40037694: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
40037698: 90 07 bf f8 add %fp, -8, %o0
4003769c: 7f ff 41 e1 call 40007e20 <_TOD_Get_with_nanoseconds>
400376a0: 92 12 63 f0 or %o1, 0x3f0, %o1
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
400376a4: c4 1f bf f8 ldd [ %fp + -8 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
400376a8: 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) {
400376ac: 03 10 01 a2 sethi %hi(0x40068800), %g1
400376b0: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 400689b0 <_Per_CPU_Information>
400376b4: de 00 60 10 ld [ %g1 + 0x10 ], %o7
400376b8: ba a0 c0 1d subcc %g3, %i5, %i5
400376bc: b8 60 80 1c subx %g2, %i4, %i4
400376c0: 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;
400376c4: 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) {
400376c8: 80 a3 c0 1b cmp %o7, %i3
400376cc: 02 80 00 05 be 400376e0 <_Rate_monotonic_Get_status+0x54>
400376d0: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
400376d4: b0 09 20 01 and %g4, 1, %i0
400376d8: 81 c7 e0 08 ret
400376dc: 81 e8 00 00 restore
400376e0: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400376e4: f0 1e 20 48 ldd [ %i0 + 0x48 ], %i0
400376e8: 86 a0 c0 0d subcc %g3, %o5, %g3
400376ec: 84 60 80 0c subx %g2, %o4, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
400376f0: 9a 87 40 03 addcc %i5, %g3, %o5
400376f4: 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))
400376f8: 80 a6 00 0c cmp %i0, %o4
400376fc: 14 bf ff f6 bg 400376d4 <_Rate_monotonic_Get_status+0x48> <== NEVER TAKEN
40037700: 88 10 20 00 clr %g4
40037704: 02 80 00 09 be 40037728 <_Rate_monotonic_Get_status+0x9c>
40037708: 80 a6 40 0d cmp %i1, %o5
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4003770c: 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;
40037710: 88 10 20 01 mov 1, %g4
40037714: 98 63 00 18 subx %o4, %i0, %o4
}
40037718: b0 09 20 01 and %g4, 1, %i0
4003771c: d8 3e 80 00 std %o4, [ %i2 ]
40037720: 81 c7 e0 08 ret
40037724: 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))
40037728: 28 bf ff fa bleu,a 40037710 <_Rate_monotonic_Get_status+0x84>
4003772c: 9a a3 40 19 subcc %o5, %i1, %o5
return false;
40037730: 10 bf ff e9 b 400376d4 <_Rate_monotonic_Get_status+0x48>
40037734: 88 10 20 00 clr %g4
40037adc <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
40037adc: 9d e3 bf 98 save %sp, -104, %sp
40037ae0: 11 10 01 a3 sethi %hi(0x40068c00), %o0
40037ae4: 92 10 00 18 mov %i0, %o1
40037ae8: 90 12 23 78 or %o0, 0x378, %o0
40037aec: 7f ff 43 a1 call 40008970 <_Objects_Get>
40037af0: 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 ) {
40037af4: c2 07 bf fc ld [ %fp + -4 ], %g1
40037af8: 80 a0 60 00 cmp %g1, 0
40037afc: 12 80 00 16 bne 40037b54 <_Rate_monotonic_Timeout+0x78> <== NEVER TAKEN
40037b00: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
40037b04: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40037b08: 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);
40037b0c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40037b10: 80 88 80 01 btst %g2, %g1
40037b14: 22 80 00 08 be,a 40037b34 <_Rate_monotonic_Timeout+0x58>
40037b18: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40037b1c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
40037b20: c2 07 60 08 ld [ %i5 + 8 ], %g1
40037b24: 80 a0 80 01 cmp %g2, %g1
40037b28: 02 80 00 19 be 40037b8c <_Rate_monotonic_Timeout+0xb0>
40037b2c: 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 ) {
40037b30: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40037b34: 80 a0 60 01 cmp %g1, 1
40037b38: 02 80 00 09 be 40037b5c <_Rate_monotonic_Timeout+0x80>
40037b3c: 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;
40037b40: 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;
40037b44: 03 10 01 a1 sethi %hi(0x40068400), %g1
40037b48: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 400684a0 <_Thread_Dispatch_disable_level>
--level;
40037b4c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40037b50: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ]
40037b54: 81 c7 e0 08 ret
40037b58: 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;
40037b5c: 82 10 20 03 mov 3, %g1
_Rate_monotonic_Initiate_statistics( the_period );
40037b60: 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;
40037b64: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
40037b68: 7f ff ff 43 call 40037874 <_Rate_monotonic_Initiate_statistics>
40037b6c: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40037b70: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40037b74: 11 10 01 a1 sethi %hi(0x40068400), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40037b78: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40037b7c: 90 12 21 38 or %o0, 0x138, %o0
40037b80: 7f ff 4a 6f call 4000a53c <_Watchdog_Insert>
40037b84: 92 07 60 10 add %i5, 0x10, %o1
40037b88: 30 bf ff ef b,a 40037b44 <_Rate_monotonic_Timeout+0x68>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40037b8c: 7f ff 46 43 call 40009498 <_Thread_Clear_state>
40037b90: 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 );
40037b94: 10 bf ff f5 b 40037b68 <_Rate_monotonic_Timeout+0x8c>
40037b98: 90 10 00 1d mov %i5, %o0
40037738 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
40037738: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
4003773c: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
40037740: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
40037744: 84 00 a0 01 inc %g2
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
40037748: 80 a0 60 04 cmp %g1, 4
4003774c: 02 80 00 32 be 40037814 <_Rate_monotonic_Update_statistics+0xdc>
40037750: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
40037754: 90 10 00 18 mov %i0, %o0
40037758: 92 07 bf f8 add %fp, -8, %o1
4003775c: 7f ff ff cc call 4003768c <_Rate_monotonic_Get_status>
40037760: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
40037764: 80 8a 20 ff btst 0xff, %o0
40037768: 02 80 00 21 be 400377ec <_Rate_monotonic_Update_statistics+0xb4>
4003776c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40037770: 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 ) )
40037774: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
40037778: b6 87 40 03 addcc %i5, %g3, %i3
4003777c: b4 47 00 02 addx %i4, %g2, %i2
40037780: 80 a0 40 02 cmp %g1, %g2
40037784: 04 80 00 1c ble 400377f4 <_Rate_monotonic_Update_statistics+0xbc>
40037788: f4 3e 20 70 std %i2, [ %i0 + 0x70 ]
stats->min_cpu_time = executed;
4003778c: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
40037790: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
40037794: 80 a0 40 02 cmp %g1, %g2
40037798: 26 80 00 05 bl,a 400377ac <_Rate_monotonic_Update_statistics+0x74><== NEVER TAKEN
4003779c: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
400377a0: 80 a0 40 02 cmp %g1, %g2
400377a4: 22 80 00 28 be,a 40037844 <_Rate_monotonic_Update_statistics+0x10c><== ALWAYS TAKEN
400377a8: 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 );
400377ac: c4 1f bf f8 ldd [ %fp + -8 ], %g2
400377b0: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
400377b4: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
400377b8: b6 87 40 03 addcc %i5, %g3, %i3
400377bc: b4 47 00 02 addx %i4, %g2, %i2
400377c0: 80 a0 40 02 cmp %g1, %g2
400377c4: 14 80 00 1b bg 40037830 <_Rate_monotonic_Update_statistics+0xf8>
400377c8: f4 3e 20 88 std %i2, [ %i0 + 0x88 ]
400377cc: 80 a0 40 02 cmp %g1, %g2
400377d0: 22 80 00 15 be,a 40037824 <_Rate_monotonic_Update_statistics+0xec><== ALWAYS TAKEN
400377d4: 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 ) )
400377d8: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
400377dc: 80 a0 40 02 cmp %g1, %g2
400377e0: 16 80 00 1e bge 40037858 <_Rate_monotonic_Update_statistics+0x120><== ALWAYS TAKEN
400377e4: 01 00 00 00 nop
stats->max_wall_time = since_last_period;
400377e8: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
400377ec: 81 c7 e0 08 ret
400377f0: 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 ) )
400377f4: 32 bf ff e8 bne,a 40037794 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN
400377f8: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
400377fc: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
40037800: 80 a0 40 03 cmp %g1, %g3
40037804: 28 bf ff e4 bleu,a 40037794 <_Rate_monotonic_Update_statistics+0x5c>
40037808: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
4003780c: 10 bf ff e1 b 40037790 <_Rate_monotonic_Update_statistics+0x58>
40037810: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
40037814: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
40037818: 82 00 60 01 inc %g1
4003781c: 10 bf ff ce b 40037754 <_Rate_monotonic_Update_statistics+0x1c>
40037820: 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 ) )
40037824: 80 a0 40 03 cmp %g1, %g3
40037828: 28 bf ff ed bleu,a 400377dc <_Rate_monotonic_Update_statistics+0xa4>
4003782c: 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 ) )
40037830: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40037834: 80 a0 40 02 cmp %g1, %g2
40037838: 06 bf ff ec bl 400377e8 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
4003783c: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
40037840: 30 80 00 06 b,a 40037858 <_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 ) )
40037844: 80 a0 40 03 cmp %g1, %g3
40037848: 3a bf ff da bcc,a 400377b0 <_Rate_monotonic_Update_statistics+0x78>
4003784c: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
40037850: 10 bf ff d7 b 400377ac <_Rate_monotonic_Update_statistics+0x74>
40037854: 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 ) )
40037858: 12 bf ff e5 bne 400377ec <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
4003785c: 01 00 00 00 nop
40037860: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40037864: 80 a0 40 03 cmp %g1, %g3
40037868: 2a bf ff e1 bcs,a 400377ec <_Rate_monotonic_Update_statistics+0xb4>
4003786c: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
40037870: 30 bf ff df b,a 400377ec <_Rate_monotonic_Update_statistics+0xb4>
40009dbc <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
40009dbc: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
40009dc0: 40 00 07 11 call 4000ba04 <_Workspace_Allocate>
40009dc4: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
40009dc8: 80 a2 20 00 cmp %o0, 0
40009dcc: 02 80 00 06 be 40009de4 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
40009dd0: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
40009dd4: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
40009dd8: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
40009ddc: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
40009de0: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
40009de4: 81 c7 e0 08 ret
40009de8: 91 e8 00 08 restore %g0, %o0, %o0
4000b190 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
4000b190: 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;
4000b194: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000b198: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000b19c: 80 a0 40 09 cmp %g1, %o1
4000b1a0: 32 80 00 02 bne,a 4000b1a8 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
4000b1a4: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
4000b1a8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000b1ac: 80 a0 40 09 cmp %g1, %o1
4000b1b0: 02 80 00 04 be 4000b1c0 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
4000b1b4: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
4000b1b8: 40 00 01 92 call 4000b800 <_Thread_Change_priority>
4000b1bc: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
4000b1c0: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
4000b1c4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000b1c8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000b1cc: 80 a0 a0 00 cmp %g2, 0
4000b1d0: 02 80 00 09 be 4000b1f4 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
4000b1d4: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
4000b1d8: d0 00 40 00 ld [ %g1 ], %o0
4000b1dc: 7f ff ff d5 call 4000b130 <_Scheduler_CBS_Get_server_id>
4000b1e0: 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 );
4000b1e4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000b1e8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000b1ec: 9f c0 40 00 call %g1
4000b1f0: d0 07 bf fc ld [ %fp + -4 ], %o0
4000b1f4: 81 c7 e0 08 ret
4000b1f8: 81 e8 00 00 restore
4000ace8 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
4000ace8: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000acec: 39 10 00 86 sethi %hi(0x40021800), %i4
4000acf0: c2 07 23 20 ld [ %i4 + 0x320 ], %g1 ! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000acf4: 80 a0 60 00 cmp %g1, 0
4000acf8: 02 80 00 18 be 4000ad58 <_Scheduler_CBS_Cleanup+0x70> <== NEVER TAKEN
4000acfc: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000ad00: 37 10 00 8b sethi %hi(0x40022c00), %i3
4000ad04: c4 06 e0 38 ld [ %i3 + 0x38 ], %g2 ! 40022c38 <_Scheduler_CBS_Server_list>
4000ad08: ba 10 20 00 clr %i5
4000ad0c: b8 17 23 20 or %i4, 0x320, %i4
if ( _Scheduler_CBS_Server_list[ i ] )
4000ad10: 83 2f 60 02 sll %i5, 2, %g1
4000ad14: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000ad18: 80 a0 60 00 cmp %g1, 0
4000ad1c: 02 80 00 05 be 4000ad30 <_Scheduler_CBS_Cleanup+0x48>
4000ad20: 90 10 00 1d mov %i5, %o0
_Scheduler_CBS_Destroy_server( i );
4000ad24: 40 00 00 46 call 4000ae3c <_Scheduler_CBS_Destroy_server>
4000ad28: 01 00 00 00 nop
4000ad2c: c4 06 e0 38 ld [ %i3 + 0x38 ], %g2
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000ad30: c2 07 00 00 ld [ %i4 ], %g1
4000ad34: ba 07 60 01 inc %i5
4000ad38: 80 a0 40 1d cmp %g1, %i5
4000ad3c: 18 bf ff f6 bgu 4000ad14 <_Scheduler_CBS_Cleanup+0x2c>
4000ad40: 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;
}
4000ad44: 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 );
4000ad48: 40 00 08 41 call 4000ce4c <_Workspace_Free>
4000ad4c: 90 10 00 02 mov %g2, %o0
return SCHEDULER_CBS_OK;
}
4000ad50: 81 c7 e0 08 ret
4000ad54: 81 e8 00 00 restore
4000ad58: 10 bf ff fb b 4000ad44 <_Scheduler_CBS_Cleanup+0x5c> <== NOT EXECUTED
4000ad5c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 <== NOT EXECUTED
4000ad60 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
4000ad60: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
4000ad64: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000ad68: 80 a0 60 00 cmp %g1, 0
4000ad6c: 04 80 00 30 ble 4000ae2c <_Scheduler_CBS_Create_server+0xcc>
4000ad70: b8 10 00 18 mov %i0, %i4
4000ad74: c2 06 00 00 ld [ %i0 ], %g1
4000ad78: 80 a0 60 00 cmp %g1, 0
4000ad7c: 04 80 00 2c ble 4000ae2c <_Scheduler_CBS_Create_server+0xcc>
4000ad80: 03 10 00 86 sethi %hi(0x40021800), %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++ ) {
4000ad84: c8 00 63 20 ld [ %g1 + 0x320 ], %g4 ! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000ad88: 80 a1 20 00 cmp %g4, 0
4000ad8c: 02 80 00 11 be 4000add0 <_Scheduler_CBS_Create_server+0x70><== NEVER TAKEN
4000ad90: 37 10 00 8b sethi %hi(0x40022c00), %i3
if ( !_Scheduler_CBS_Server_list[i] )
4000ad94: fa 06 e0 38 ld [ %i3 + 0x38 ], %i5 ! 40022c38 <_Scheduler_CBS_Server_list>
4000ad98: c2 07 40 00 ld [ %i5 ], %g1
4000ad9c: 80 a0 60 00 cmp %g1, 0
4000ada0: 02 80 00 21 be 4000ae24 <_Scheduler_CBS_Create_server+0xc4>
4000ada4: b0 10 20 00 clr %i0
4000ada8: 10 80 00 06 b 4000adc0 <_Scheduler_CBS_Create_server+0x60>
4000adac: 82 10 20 00 clr %g1
4000adb0: c6 07 40 02 ld [ %i5 + %g2 ], %g3
4000adb4: 80 a0 e0 00 cmp %g3, 0
4000adb8: 02 80 00 08 be 4000add8 <_Scheduler_CBS_Create_server+0x78>
4000adbc: 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++ ) {
4000adc0: 82 00 60 01 inc %g1
4000adc4: 80 a0 40 04 cmp %g1, %g4
4000adc8: 12 bf ff fa bne 4000adb0 <_Scheduler_CBS_Create_server+0x50>
4000adcc: 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;
4000add0: 81 c7 e0 08 ret
4000add4: 91 e8 3f e6 restore %g0, -26, %o0
*server_id = i;
4000add8: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
4000addc: 40 00 08 14 call 4000ce2c <_Workspace_Allocate>
4000ade0: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
4000ade4: 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 *)
4000ade8: d0 27 40 18 st %o0, [ %i5 + %i0 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
4000adec: c4 06 e0 38 ld [ %i3 + 0x38 ], %g2
4000adf0: 83 28 60 02 sll %g1, 2, %g1
4000adf4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
4000adf8: 80 a0 60 00 cmp %g1, 0
4000adfc: 02 80 00 0e be 4000ae34 <_Scheduler_CBS_Create_server+0xd4><== NEVER TAKEN
4000ae00: 86 10 3f ff mov -1, %g3
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
4000ae04: c4 07 00 00 ld [ %i4 ], %g2
4000ae08: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000ae0c: c4 07 20 04 ld [ %i4 + 4 ], %g2
the_server->task_id = -1;
4000ae10: 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;
4000ae14: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
4000ae18: f2 20 60 0c st %i1, [ %g1 + 0xc ]
return SCHEDULER_CBS_OK;
4000ae1c: 81 c7 e0 08 ret
4000ae20: 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] )
4000ae24: 10 bf ff ed b 4000add8 <_Scheduler_CBS_Create_server+0x78>
4000ae28: 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;
4000ae2c: 81 c7 e0 08 ret
4000ae30: 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;
}
4000ae34: 81 c7 e0 08 ret <== NOT EXECUTED
4000ae38: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
4000aebc <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
4000aebc: 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);
4000aec0: 92 07 bf fc add %fp, -4, %o1
4000aec4: 40 00 03 95 call 4000bd18 <_Thread_Get>
4000aec8: 90 10 00 19 mov %i1, %o0
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
4000aecc: ba 92 20 00 orcc %o0, 0, %i5
4000aed0: 02 80 00 1e be 4000af48 <_Scheduler_CBS_Detach_thread+0x8c>
4000aed4: 01 00 00 00 nop
_Thread_Enable_dispatch();
4000aed8: 40 00 03 84 call 4000bce8 <_Thread_Enable_dispatch>
4000aedc: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000aee0: 03 10 00 86 sethi %hi(0x40021800), %g1
4000aee4: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000aee8: 80 a6 00 01 cmp %i0, %g1
4000aeec: 1a 80 00 17 bcc 4000af48 <_Scheduler_CBS_Detach_thread+0x8c>
4000aef0: 03 10 00 8b sethi %hi(0x40022c00), %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] )
4000aef4: c2 00 60 38 ld [ %g1 + 0x38 ], %g1 ! 40022c38 <_Scheduler_CBS_Server_list>
4000aef8: b1 2e 20 02 sll %i0, 2, %i0
4000aefc: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000af00: 80 a0 60 00 cmp %g1, 0
4000af04: 02 80 00 13 be 4000af50 <_Scheduler_CBS_Detach_thread+0x94>
4000af08: 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 )
4000af0c: c4 00 40 00 ld [ %g1 ], %g2
4000af10: 80 a0 80 19 cmp %g2, %i1
4000af14: 12 80 00 0d bne 4000af48 <_Scheduler_CBS_Detach_thread+0x8c><== NEVER TAKEN
4000af18: 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;
4000af1c: c8 07 60 88 ld [ %i5 + 0x88 ], %g4
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000af20: 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;
4000af24: 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;
4000af28: c4 07 60 a4 ld [ %i5 + 0xa4 ], %g2
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000af2c: 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;
4000af30: c0 21 20 18 clr [ %g4 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000af34: c6 27 60 78 st %g3, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
4000af38: c4 27 60 7c st %g2, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000af3c: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
4000af40: 81 c7 e0 08 ret
4000af44: 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;
4000af48: 81 c7 e0 08 ret
4000af4c: 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;
}
4000af50: 81 c7 e0 08 ret
4000af54: 91 e8 3f e7 restore %g0, -25, %o0
4000b130 <_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++ ) {
4000b130: 03 10 00 86 sethi %hi(0x40021800), %g1
4000b134: c6 00 63 20 ld [ %g1 + 0x320 ], %g3 ! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000b138: 80 a0 e0 00 cmp %g3, 0
4000b13c: 02 80 00 11 be 4000b180 <_Scheduler_CBS_Get_server_id+0x50><== NEVER TAKEN
4000b140: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000b144: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 ! 40022c38 <_Scheduler_CBS_Server_list>
4000b148: 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 (
4000b14c: 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] &&
4000b150: c4 01 00 02 ld [ %g4 + %g2 ], %g2
4000b154: 80 a0 a0 00 cmp %g2, 0
4000b158: 22 80 00 07 be,a 4000b174 <_Scheduler_CBS_Get_server_id+0x44>
4000b15c: 82 00 60 01 inc %g1
4000b160: c4 00 80 00 ld [ %g2 ], %g2
4000b164: 80 a0 80 08 cmp %g2, %o0
4000b168: 22 80 00 08 be,a 4000b188 <_Scheduler_CBS_Get_server_id+0x58>
4000b16c: 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++ ) {
4000b170: 82 00 60 01 inc %g1
4000b174: 80 a0 40 03 cmp %g1, %g3
4000b178: 12 bf ff f6 bne 4000b150 <_Scheduler_CBS_Get_server_id+0x20>
4000b17c: 85 28 60 02 sll %g1, 2, %g2
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
4000b180: 81 c3 e0 08 retl
4000b184: 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;
4000b188: 81 c3 e0 08 retl
4000b18c: 90 10 20 00 clr %o0
4000b1fc <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
4000b1fc: 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*) );
4000b200: 3b 10 00 86 sethi %hi(0x40021800), %i5
4000b204: d0 07 63 20 ld [ %i5 + 0x320 ], %o0 ! 40021b20 <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
4000b208: 40 00 07 09 call 4000ce2c <_Workspace_Allocate>
4000b20c: 91 2a 20 02 sll %o0, 2, %o0
4000b210: 09 10 00 8b sethi %hi(0x40022c00), %g4
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
4000b214: 80 a2 20 00 cmp %o0, 0
4000b218: 02 80 00 10 be 4000b258 <_Scheduler_CBS_Initialize+0x5c> <== NEVER TAKEN
4000b21c: d0 21 20 38 st %o0, [ %g4 + 0x38 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000b220: c6 07 63 20 ld [ %i5 + 0x320 ], %g3
4000b224: 80 a0 e0 00 cmp %g3, 0
4000b228: 12 80 00 05 bne 4000b23c <_Scheduler_CBS_Initialize+0x40> <== ALWAYS TAKEN
4000b22c: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
4000b230: 81 c7 e0 08 ret <== NOT EXECUTED
4000b234: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000b238: d0 01 20 38 ld [ %g4 + 0x38 ], %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;
4000b23c: 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++) {
4000b240: 82 00 60 01 inc %g1
4000b244: 80 a0 40 03 cmp %g1, %g3
4000b248: 12 bf ff fc bne 4000b238 <_Scheduler_CBS_Initialize+0x3c>
4000b24c: c0 22 00 02 clr [ %o0 + %g2 ]
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
4000b250: 81 c7 e0 08 ret
4000b254: 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;
4000b258: 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;
}
4000b25c: 81 c7 e0 08 ret <== NOT EXECUTED
4000b260: 81 e8 00 00 restore <== NOT EXECUTED
40009dec <_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;
40009dec: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
40009df0: 80 a2 60 00 cmp %o1, 0
40009df4: 02 80 00 11 be 40009e38 <_Scheduler_CBS_Release_job+0x4c>
40009df8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
40009dfc: 80 a0 60 00 cmp %g1, 0
40009e00: 02 80 00 13 be 40009e4c <_Scheduler_CBS_Release_job+0x60>
40009e04: 07 10 00 83 sethi %hi(0x40020c00), %g3
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
40009e08: c4 00 60 04 ld [ %g1 + 4 ], %g2
40009e0c: d2 00 e0 08 ld [ %g3 + 8 ], %o1
40009e10: 92 02 40 02 add %o1, %g2, %o1
40009e14: 05 20 00 00 sethi %hi(0x80000000), %g2
40009e18: 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;
40009e1c: c2 00 60 08 ld [ %g1 + 8 ], %g1
40009e20: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
40009e24: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
40009e28: 94 10 20 01 mov 1, %o2
40009e2c: 82 13 c0 00 mov %o7, %g1
40009e30: 40 00 01 3a call 4000a318 <_Thread_Change_priority>
40009e34: 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)
40009e38: 80 a0 60 00 cmp %g1, 0
40009e3c: 12 bf ff f8 bne 40009e1c <_Scheduler_CBS_Release_job+0x30><== ALWAYS TAKEN
40009e40: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
the_thread->real_priority = new_priority;
40009e44: 10 bf ff f9 b 40009e28 <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED
40009e48: 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)
40009e4c: 03 10 00 83 sethi %hi(0x40020c00), %g1
40009e50: c2 00 60 08 ld [ %g1 + 8 ], %g1 ! 40020c08 <_Watchdog_Ticks_since_boot>
40009e54: 92 02 40 01 add %o1, %g1, %o1
40009e58: 03 20 00 00 sethi %hi(0x80000000), %g1
40009e5c: 10 bf ff f2 b 40009e24 <_Scheduler_CBS_Release_job+0x38>
40009e60: 92 2a 40 01 andn %o1, %g1, %o1
40009e64 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
40009e64: 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);
40009e68: 40 00 00 50 call 40009fa8 <_Scheduler_EDF_Enqueue>
40009e6c: 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;
40009e70: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
40009e74: 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) {
40009e78: 80 a7 60 00 cmp %i5, 0
40009e7c: 02 80 00 19 be 40009ee0 <_Scheduler_CBS_Unblock+0x7c>
40009e80: 03 10 00 83 sethi %hi(0x40020c00), %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 ) {
40009e84: 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 -
40009e88: d0 00 60 08 ld [ %g1 + 8 ], %o0
40009e8c: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
40009e90: 40 00 40 c1 call 4001a194 <.umul>
40009e94: 90 27 00 08 sub %i4, %o0, %o0
40009e98: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
40009e9c: b6 10 00 08 mov %o0, %i3
40009ea0: 40 00 40 bd call 4001a194 <.umul>
40009ea4: d0 07 60 08 ld [ %i5 + 8 ], %o0
40009ea8: 80 a6 c0 08 cmp %i3, %o0
40009eac: 24 80 00 0e ble,a 40009ee4 <_Scheduler_CBS_Unblock+0x80>
40009eb0: 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;
40009eb4: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
40009eb8: 80 a7 00 09 cmp %i4, %o1
40009ebc: 32 80 00 02 bne,a 40009ec4 <_Scheduler_CBS_Unblock+0x60>
40009ec0: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
40009ec4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40009ec8: 80 a2 00 09 cmp %o0, %o1
40009ecc: 02 80 00 07 be 40009ee8 <_Scheduler_CBS_Unblock+0x84>
40009ed0: 3b 10 00 84 sethi %hi(0x40021000), %i5
_Thread_Change_priority(the_thread, new_priority, true);
40009ed4: 90 10 00 18 mov %i0, %o0
40009ed8: 40 00 01 10 call 4000a318 <_Thread_Change_priority>
40009edc: 94 10 20 01 mov 1, %o2
40009ee0: 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,
40009ee4: 3b 10 00 84 sethi %hi(0x40021000), %i5
40009ee8: ba 17 60 30 or %i5, 0x30, %i5 ! 40021030 <_Per_CPU_Information>
40009eec: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40009ef0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1
40009ef4: 03 10 00 7f sethi %hi(0x4001fc00), %g1
40009ef8: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 4001ff74 <_Scheduler+0x30>
40009efc: 9f c0 40 00 call %g1
40009f00: 01 00 00 00 nop
40009f04: 80 a2 20 00 cmp %o0, 0
40009f08: 04 80 00 0a ble 40009f30 <_Scheduler_CBS_Unblock+0xcc>
40009f0c: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
40009f10: 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;
40009f14: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
40009f18: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
40009f1c: 80 a0 60 00 cmp %g1, 0
40009f20: 22 80 00 06 be,a 40009f38 <_Scheduler_CBS_Unblock+0xd4>
40009f24: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
40009f28: 82 10 20 01 mov 1, %g1
40009f2c: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
40009f30: 81 c7 e0 08 ret
40009f34: 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 ||
40009f38: 80 a0 60 00 cmp %g1, 0
40009f3c: 12 bf ff fd bne 40009f30 <_Scheduler_CBS_Unblock+0xcc> <== ALWAYS TAKEN
40009f40: 82 10 20 01 mov 1, %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
40009f44: c2 2f 60 0c stb %g1, [ %i5 + 0xc ] <== NOT EXECUTED
40009f48: 30 bf ff fa b,a 40009f30 <_Scheduler_CBS_Unblock+0xcc> <== NOT EXECUTED
40009dbc <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
40009dbc: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
40009dc0: 40 00 06 e8 call 4000b960 <_Workspace_Allocate>
40009dc4: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
40009dc8: 80 a2 20 00 cmp %o0, 0
40009dcc: 02 80 00 05 be 40009de0 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
40009dd0: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
40009dd4: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
40009dd8: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
40009ddc: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
40009de0: 81 c7 e0 08 ret
40009de4: 91 e8 00 08 restore %g0, %o0, %o0
40009fa0 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
40009fa0: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
40009fa4: 7f ff ff a8 call 40009e44 <_Scheduler_EDF_Enqueue>
40009fa8: 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(
40009fac: 3b 10 00 83 sethi %hi(0x40020c00), %i5
40009fb0: ba 17 63 90 or %i5, 0x390, %i5 ! 40020f90 <_Per_CPU_Information>
40009fb4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40009fb8: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
40009fbc: 03 10 00 7f sethi %hi(0x4001fc00), %g1
40009fc0: c2 00 62 d4 ld [ %g1 + 0x2d4 ], %g1 ! 4001fed4 <_Scheduler+0x30>
40009fc4: 9f c0 40 00 call %g1
40009fc8: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
40009fcc: 80 a2 20 00 cmp %o0, 0
40009fd0: 26 80 00 04 bl,a 40009fe0 <_Scheduler_EDF_Unblock+0x40>
40009fd4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40009fd8: 81 c7 e0 08 ret
40009fdc: 81 e8 00 00 restore
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
40009fe0: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
40009fe4: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
40009fe8: 80 a0 60 00 cmp %g1, 0
40009fec: 22 80 00 06 be,a 4000a004 <_Scheduler_EDF_Unblock+0x64>
40009ff0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
40009ff4: 82 10 20 01 mov 1, %g1
40009ff8: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
40009ffc: 81 c7 e0 08 ret
4000a000: 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 ||
4000a004: 80 a0 60 00 cmp %g1, 0
4000a008: 12 bf ff f4 bne 40009fd8 <_Scheduler_EDF_Unblock+0x38> <== ALWAYS TAKEN
4000a00c: 82 10 20 01 mov 1, %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000a010: c2 2f 60 0c stb %g1, [ %i5 + 0xc ] <== NOT EXECUTED
4000a014: 30 bf ff fa b,a 40009ffc <_Scheduler_EDF_Unblock+0x5c> <== NOT EXECUTED
40009710 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
40009710: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
executing = _Thread_Executing;
40009714: 03 10 00 7c sethi %hi(0x4001f000), %g1
40009718: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 4001f3e0 <_Per_CPU_Information+0x10>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
4000971c: c2 0a 20 70 ldub [ %o0 + 0x70 ], %g1
40009720: 80 a0 60 00 cmp %g1, 0
40009724: 02 80 00 26 be 400097bc <_Scheduler_priority_Tick+0xac>
40009728: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
4000972c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40009730: 80 a0 60 00 cmp %g1, 0
40009734: 12 80 00 22 bne 400097bc <_Scheduler_priority_Tick+0xac>
40009738: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
4000973c: c2 02 20 78 ld [ %o0 + 0x78 ], %g1
40009740: 80 a0 60 01 cmp %g1, 1
40009744: 0a 80 00 07 bcs 40009760 <_Scheduler_priority_Tick+0x50>
40009748: 80 a0 60 02 cmp %g1, 2
4000974c: 28 80 00 10 bleu,a 4000978c <_Scheduler_priority_Tick+0x7c>
40009750: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
40009754: 80 a0 60 03 cmp %g1, 3
40009758: 22 80 00 04 be,a 40009768 <_Scheduler_priority_Tick+0x58><== ALWAYS TAKEN
4000975c: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
40009760: 81 c7 e0 08 ret
40009764: 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 )
40009768: 82 00 7f ff add %g1, -1, %g1
4000976c: 80 a0 60 00 cmp %g1, 0
40009770: 12 bf ff fc bne 40009760 <_Scheduler_priority_Tick+0x50>
40009774: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
(*executing->budget_callout)( executing );
40009778: c2 02 20 7c ld [ %o0 + 0x7c ], %g1
4000977c: 9f c0 40 00 call %g1
40009780: 01 00 00 00 nop
40009784: 81 c7 e0 08 ret
40009788: 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 ) {
4000978c: 82 00 7f ff add %g1, -1, %g1
40009790: 80 a0 60 00 cmp %g1, 0
40009794: 14 bf ff f3 bg 40009760 <_Scheduler_priority_Tick+0x50>
40009798: 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();
4000979c: 03 10 00 78 sethi %hi(0x4001e000), %g1
400097a0: c2 00 63 70 ld [ %g1 + 0x370 ], %g1 ! 4001e370 <_Scheduler+0xc>
400097a4: 9f c0 40 00 call %g1
400097a8: 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;
400097ac: 03 10 00 7b sethi %hi(0x4001ec00), %g1
400097b0: d0 07 bf fc ld [ %fp + -4 ], %o0
400097b4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1
400097b8: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
400097bc: 81 c7 e0 08 ret
400097c0: 81 e8 00 00 restore
40009fb8 <_Scheduler_simple_Ready_queue_enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
40009fb8: 03 10 00 7c sethi %hi(0x4001f000), %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40009fbc: c2 00 63 64 ld [ %g1 + 0x364 ], %g1 ! 4001f364 <_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 ) {
40009fc0: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
40009fc4: c2 00 40 00 ld [ %g1 ], %g1
40009fc8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40009fcc: 80 a0 80 03 cmp %g2, %g3
40009fd0: 3a 80 00 08 bcc,a 40009ff0 <_Scheduler_simple_Ready_queue_enqueue_first+0x38>
40009fd4: 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 ) {
40009fd8: 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 ) {
40009fdc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40009fe0: 80 a0 80 03 cmp %g2, %g3
40009fe4: 2a bf ff fe bcs,a 40009fdc <_Scheduler_simple_Ready_queue_enqueue_first+0x24><== NEVER TAKEN
40009fe8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
40009fec: c2 00 60 04 ld [ %g1 + 4 ], %g1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40009ff0: c4 00 40 00 ld [ %g1 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40009ff4: c2 22 20 04 st %g1, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
40009ff8: d0 20 40 00 st %o0, [ %g1 ]
the_node->next = before_node;
40009ffc: c4 22 00 00 st %g2, [ %o0 ]
before_node->previous = the_node;
4000a000: 81 c3 e0 08 retl
4000a004: d0 20 a0 04 st %o0, [ %g2 + 4 ]
40008034 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
40008034: 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();
40008038: 03 10 00 79 sethi %hi(0x4001e400), %g1
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
4000803c: d2 00 62 7c ld [ %g1 + 0x27c ], %o1 ! 4001e67c <Configuration+0xc>
40008040: 11 00 03 d0 sethi %hi(0xf4000), %o0
40008044: 40 00 4a 77 call 4001aa20 <.udiv>
40008048: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
4000804c: 80 a6 20 00 cmp %i0, 0
40008050: 02 80 00 2c be 40008100 <_TOD_Validate+0xcc> <== NEVER TAKEN
40008054: 82 10 20 00 clr %g1
40008058: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
4000805c: 80 a2 00 02 cmp %o0, %g2
40008060: 28 80 00 26 bleu,a 400080f8 <_TOD_Validate+0xc4>
40008064: b0 08 60 01 and %g1, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
40008068: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4000806c: 80 a0 a0 3b cmp %g2, 0x3b
40008070: 38 80 00 22 bgu,a 400080f8 <_TOD_Validate+0xc4>
40008074: b0 08 60 01 and %g1, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
40008078: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000807c: 80 a0 a0 3b cmp %g2, 0x3b
40008080: 38 80 00 1e bgu,a 400080f8 <_TOD_Validate+0xc4>
40008084: b0 08 60 01 and %g1, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
40008088: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000808c: 80 a0 a0 17 cmp %g2, 0x17
40008090: 38 80 00 1a bgu,a 400080f8 <_TOD_Validate+0xc4>
40008094: b0 08 60 01 and %g1, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
40008098: 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) ||
4000809c: 80 a0 a0 00 cmp %g2, 0
400080a0: 02 80 00 15 be 400080f4 <_TOD_Validate+0xc0> <== NEVER TAKEN
400080a4: 80 a0 a0 0c cmp %g2, 0xc
(the_tod->month == 0) ||
400080a8: 38 80 00 14 bgu,a 400080f8 <_TOD_Validate+0xc4>
400080ac: b0 08 60 01 and %g1, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
400080b0: 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) ||
400080b4: 80 a0 e7 c3 cmp %g3, 0x7c3
400080b8: 28 80 00 10 bleu,a 400080f8 <_TOD_Validate+0xc4>
400080bc: b0 08 60 01 and %g1, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
400080c0: 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) ||
400080c4: 80 a1 20 00 cmp %g4, 0
400080c8: 02 80 00 0b be 400080f4 <_TOD_Validate+0xc0> <== NEVER TAKEN
400080cc: 80 88 e0 03 btst 3, %g3
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
400080d0: 32 80 00 0f bne,a 4000810c <_TOD_Validate+0xd8>
400080d4: 85 28 a0 02 sll %g2, 2, %g2
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
400080d8: 82 00 a0 0d add %g2, 0xd, %g1
400080dc: 05 10 00 7d sethi %hi(0x4001f400), %g2
400080e0: 83 28 60 02 sll %g1, 2, %g1
400080e4: 84 10 a3 70 or %g2, 0x370, %g2
400080e8: 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 )
400080ec: 80 a0 40 04 cmp %g1, %g4
400080f0: 82 60 3f ff subx %g0, -1, %g1
return false;
return true;
}
400080f4: b0 08 60 01 and %g1, 1, %i0
400080f8: 81 c7 e0 08 ret
400080fc: 81 e8 00 00 restore
40008100: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
40008104: 81 c7 e0 08 ret <== NOT EXECUTED
40008108: 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 ];
4000810c: 03 10 00 7d sethi %hi(0x4001f400), %g1
40008110: 82 10 63 70 or %g1, 0x370, %g1 ! 4001f770 <_TOD_Days_per_month>
40008114: c2 00 40 02 ld [ %g1 + %g2 ], %g1
if ( the_tod->day > days_in_month )
40008118: 80 a0 40 04 cmp %g1, %g4
4000811c: 10 bf ff f6 b 400080f4 <_TOD_Validate+0xc0>
40008120: 82 60 3f ff subx %g0, -1, %g1
400099e0 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
400099e0: 9d e3 bf a0 save %sp, -96, %sp
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
400099e4: 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 );
400099e8: 40 00 03 9a call 4000a850 <_Thread_Set_transient>
400099ec: 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 )
400099f0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400099f4: 80 a0 40 19 cmp %g1, %i1
400099f8: 02 80 00 05 be 40009a0c <_Thread_Change_priority+0x2c>
400099fc: ba 10 00 18 mov %i0, %i5
_Thread_Set_priority( the_thread, new_priority );
40009a00: 90 10 00 18 mov %i0, %o0
40009a04: 40 00 03 79 call 4000a7e8 <_Thread_Set_priority>
40009a08: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
40009a0c: 7f ff e1 a6 call 400020a4 <sparc_disable_interrupts>
40009a10: 01 00 00 00 nop
40009a14: 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;
40009a18: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
40009a1c: 80 a7 20 04 cmp %i4, 4
40009a20: 02 80 00 18 be 40009a80 <_Thread_Change_priority+0xa0>
40009a24: 80 8e e0 04 btst 4, %i3
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
40009a28: 02 80 00 0b be 40009a54 <_Thread_Change_priority+0x74> <== ALWAYS TAKEN
40009a2c: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
40009a30: 7f ff e1 a1 call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40009a34: 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);
40009a38: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
40009a3c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
if ( _States_Is_waiting_on_thread_queue( state ) ) {
40009a40: 80 8f 00 01 btst %i4, %g1 <== NOT EXECUTED
40009a44: 32 80 00 0d bne,a 40009a78 <_Thread_Change_priority+0x98><== NOT EXECUTED
40009a48: f0 07 60 44 ld [ %i5 + 0x44 ], %i0 <== NOT EXECUTED
40009a4c: 81 c7 e0 08 ret
40009a50: 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 );
40009a54: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
40009a58: 7f ff e1 97 call 400020b4 <sparc_enable_interrupts>
40009a5c: 90 10 00 19 mov %i1, %o0
40009a60: 03 00 00 ef sethi %hi(0x3bc00), %g1
40009a64: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
if ( _States_Is_waiting_on_thread_queue( state ) ) {
40009a68: 80 8f 00 01 btst %i4, %g1
40009a6c: 02 bf ff f8 be 40009a4c <_Thread_Change_priority+0x6c>
40009a70: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
40009a74: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
40009a78: 40 00 03 2c call 4000a728 <_Thread_queue_Requeue>
40009a7c: 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 ) ) {
40009a80: 22 80 00 19 be,a 40009ae4 <_Thread_Change_priority+0x104><== ALWAYS TAKEN
40009a84: c0 27 60 10 clr [ %i5 + 0x10 ]
40009a88: 39 10 00 78 sethi %hi(0x4001e000), %i4 <== NOT EXECUTED
40009a8c: b8 17 23 64 or %i4, 0x364, %i4 ! 4001e364 <_Scheduler> <== NOT EXECUTED
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
40009a90: 7f ff e1 89 call 400020b4 <sparc_enable_interrupts>
40009a94: 90 10 00 19 mov %i1, %o0
40009a98: 7f ff e1 83 call 400020a4 <sparc_disable_interrupts>
40009a9c: 01 00 00 00 nop
40009aa0: 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();
40009aa4: c2 07 20 08 ld [ %i4 + 8 ], %g1
40009aa8: 9f c0 40 00 call %g1
40009aac: 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 );
40009ab0: 03 10 00 7c sethi %hi(0x4001f000), %g1
40009ab4: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 4001f3d0 <_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() &&
40009ab8: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
40009abc: 80 a0 80 03 cmp %g2, %g3
40009ac0: 02 80 00 07 be 40009adc <_Thread_Change_priority+0xfc>
40009ac4: 01 00 00 00 nop
40009ac8: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
40009acc: 80 a0 a0 00 cmp %g2, 0
40009ad0: 02 80 00 03 be 40009adc <_Thread_Change_priority+0xfc>
40009ad4: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
40009ad8: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
_ISR_Enable( level );
40009adc: 7f ff e1 76 call 400020b4 <sparc_enable_interrupts>
40009ae0: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
40009ae4: 39 10 00 78 sethi %hi(0x4001e000), %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 )
40009ae8: 80 a6 a0 00 cmp %i2, 0
40009aec: 02 80 00 06 be 40009b04 <_Thread_Change_priority+0x124>
40009af0: b8 17 23 64 or %i4, 0x364, %i4
40009af4: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
40009af8: 9f c0 40 00 call %g1
40009afc: 90 10 00 1d mov %i5, %o0
40009b00: 30 bf ff e4 b,a 40009a90 <_Thread_Change_priority+0xb0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
40009b04: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
40009b08: 9f c0 40 00 call %g1
40009b0c: 90 10 00 1d mov %i5, %o0
40009b10: 30 bf ff e0 b,a 40009a90 <_Thread_Change_priority+0xb0>
40009d00 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
40009d00: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
40009d04: 90 10 00 18 mov %i0, %o0
40009d08: 40 00 00 7c call 40009ef8 <_Thread_Get>
40009d0c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40009d10: c2 07 bf fc ld [ %fp + -4 ], %g1
40009d14: 80 a0 60 00 cmp %g1, 0
40009d18: 12 80 00 08 bne 40009d38 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
40009d1c: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
40009d20: 7f ff ff 7d call 40009b14 <_Thread_Clear_state>
40009d24: 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;
40009d28: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40009d2c: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 4001eec0 <_Thread_Dispatch_disable_level>
--level;
40009d30: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40009d34: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
40009d38: 81 c7 e0 08 ret
40009d3c: 81 e8 00 00 restore
40009d40 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
40009d40: 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;
40009d44: 31 10 00 7c sethi %hi(0x4001f000), %i0
40009d48: b0 16 23 d0 or %i0, 0x3d0, %i0 ! 4001f3d0 <_Per_CPU_Information>
_ISR_Disable( level );
40009d4c: 7f ff e0 d6 call 400020a4 <sparc_disable_interrupts>
40009d50: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
while ( _Thread_Dispatch_necessary == true ) {
40009d54: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
40009d58: 80 a0 60 00 cmp %g1, 0
40009d5c: 02 80 00 46 be 40009e74 <_Thread_Dispatch+0x134>
40009d60: 21 10 00 7b sethi %hi(0x4001ec00), %l0
heir = _Thread_Heir;
40009d64: 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;
40009d68: 82 10 20 01 mov 1, %g1
40009d6c: c2 24 22 c0 st %g1, [ %l0 + 0x2c0 ]
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
40009d70: 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 )
40009d74: 80 a6 c0 1a cmp %i3, %i2
40009d78: 02 80 00 3f be 40009e74 <_Thread_Dispatch+0x134>
40009d7c: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
40009d80: 23 10 00 79 sethi %hi(0x4001e400), %l1
40009d84: 27 10 00 7b sethi %hi(0x4001ec00), %l3
40009d88: a2 14 60 8c or %l1, 0x8c, %l1
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40009d8c: 25 10 00 7b sethi %hi(0x4001ec00), %l2
40009d90: a6 14 e3 2c or %l3, 0x32c, %l3
40009d94: 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;
40009d98: 2b 10 00 7b sethi %hi(0x4001ec00), %l5
40009d9c: a4 14 a2 10 or %l2, 0x210, %l2
40009da0: 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 )
40009da4: c2 06 a0 78 ld [ %i2 + 0x78 ], %g1
40009da8: 80 a0 60 01 cmp %g1, 1
40009dac: 02 80 00 45 be 40009ec0 <_Thread_Dispatch+0x180>
40009db0: c2 05 62 20 ld [ %l5 + 0x220 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
40009db4: 7f ff e0 c0 call 400020b4 <sparc_enable_interrupts>
40009db8: 01 00 00 00 nop
40009dbc: 90 07 bf f8 add %fp, -8, %o0
40009dc0: 7f ff f9 8b call 400083ec <_TOD_Get_with_nanoseconds>
40009dc4: 92 10 00 12 mov %l2, %o1
40009dc8: c4 1e e0 80 ldd [ %i3 + 0x80 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40009dcc: f8 1e 20 20 ldd [ %i0 + 0x20 ], %i4
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
40009dd0: d8 1f bf f8 ldd [ %fp + -8 ], %o4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
40009dd4: c2 04 c0 00 ld [ %l3 ], %g1
40009dd8: ba a3 40 1d subcc %o5, %i5, %i5
40009ddc: b8 63 00 1c subx %o4, %i4, %i4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40009de0: 96 80 c0 1d addcc %g3, %i5, %o3
40009de4: 94 40 80 1c addx %g2, %i4, %o2
40009de8: d4 3e e0 80 std %o2, [ %i3 + 0x80 ]
40009dec: 80 a0 60 00 cmp %g1, 0
40009df0: 02 80 00 06 be 40009e08 <_Thread_Dispatch+0xc8> <== NEVER TAKEN
40009df4: d8 3e 20 20 std %o4, [ %i0 + 0x20 ]
executing->libc_reent = *_Thread_libc_reent;
40009df8: c4 00 40 00 ld [ %g1 ], %g2
40009dfc: c4 26 e1 48 st %g2, [ %i3 + 0x148 ]
*_Thread_libc_reent = heir->libc_reent;
40009e00: c4 06 a1 48 ld [ %i2 + 0x148 ], %g2
40009e04: 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;
40009e08: 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 ) {
40009e0c: 80 a7 40 19 cmp %i5, %i1
40009e10: 02 80 00 0b be 40009e3c <_Thread_Dispatch+0xfc> <== NEVER TAKEN
40009e14: 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 );
40009e18: c2 07 60 08 ld [ %i5 + 8 ], %g1
40009e1c: 90 10 00 1b mov %i3, %o0
40009e20: 9f c0 40 00 call %g1
40009e24: 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;
40009e28: 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 ) {
40009e2c: 80 a7 40 19 cmp %i5, %i1
40009e30: 32 bf ff fb bne,a 40009e1c <_Thread_Dispatch+0xdc>
40009e34: 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 );
40009e38: 90 06 e0 c0 add %i3, 0xc0, %o0
40009e3c: 40 00 04 91 call 4000b080 <_CPU_Context_switch>
40009e40: 92 06 a0 c0 add %i2, 0xc0, %o1
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
40009e44: 7f ff e0 98 call 400020a4 <sparc_disable_interrupts>
40009e48: 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 ) {
40009e4c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
40009e50: 80 a0 60 00 cmp %g1, 0
40009e54: 02 80 00 08 be 40009e74 <_Thread_Dispatch+0x134>
40009e58: 01 00 00 00 nop
heir = _Thread_Heir;
40009e5c: f4 06 20 14 ld [ %i0 + 0x14 ], %i2
40009e60: e8 24 22 c0 st %l4, [ %l0 + 0x2c0 ]
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
40009e64: 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 )
40009e68: 80 a6 80 1b cmp %i2, %i3
40009e6c: 12 bf ff ce bne 40009da4 <_Thread_Dispatch+0x64> <== ALWAYS TAKEN
40009e70: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
40009e74: c0 24 22 c0 clr [ %l0 + 0x2c0 ]
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
40009e78: 7f ff e0 8f call 400020b4 <sparc_enable_interrupts>
40009e7c: 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;
40009e80: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40009e84: fa 00 63 30 ld [ %g1 + 0x330 ], %i5 ! 4001ef30 <_API_extensions_Post_switch_list>
40009e88: 82 10 63 30 or %g1, 0x330, %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 ) {
40009e8c: b8 00 60 04 add %g1, 4, %i4
40009e90: 80 a7 40 1c cmp %i5, %i4
40009e94: 02 80 00 09 be 40009eb8 <_Thread_Dispatch+0x178>
40009e98: 01 00 00 00 nop
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
40009e9c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40009ea0: 9f c0 40 00 call %g1
40009ea4: 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;
40009ea8: 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 ) {
40009eac: 80 a7 40 1c cmp %i5, %i4
40009eb0: 32 bf ff fc bne,a 40009ea0 <_Thread_Dispatch+0x160> <== NEVER TAKEN
40009eb4: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40009eb8: 81 c7 e0 08 ret
40009ebc: 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;
40009ec0: 10 bf ff bd b 40009db4 <_Thread_Dispatch+0x74>
40009ec4: c2 26 a0 74 st %g1, [ %i2 + 0x74 ]
4000f504 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
4000f504: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
4000f508: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000f50c: fa 00 63 e0 ld [ %g1 + 0x3e0 ], %i5 ! 4001f3e0 <_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();
4000f510: 3f 10 00 3d sethi %hi(0x4000f400), %i7
4000f514: be 17 e1 04 or %i7, 0x104, %i7 ! 4000f504 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4000f518: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
4000f51c: 7f ff ca e6 call 400020b4 <sparc_enable_interrupts>
4000f520: 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;
4000f524: 03 10 00 7a sethi %hi(0x4001e800), %g1
doneConstructors = true;
4000f528: 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;
4000f52c: f8 08 63 b8 ldub [ %g1 + 0x3b8 ], %i4
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
4000f530: 90 10 00 1d mov %i5, %o0
4000f534: 13 10 00 2a sethi %hi(0x4000a800), %o1
4000f538: 92 12 62 34 or %o1, 0x234, %o1 ! 4000aa34 <_User_extensions_Thread_begin_visitor>
4000f53c: 7f ff ed 5b call 4000aaa8 <_User_extensions_Iterate>
4000f540: c4 28 63 b8 stb %g2, [ %g1 + 0x3b8 ]
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4000f544: 7f ff ea 61 call 40009ec8 <_Thread_Enable_dispatch>
4000f548: 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) */ {
4000f54c: 80 8f 20 ff btst 0xff, %i4
4000f550: 02 80 00 10 be 4000f590 <_Thread_Handler+0x8c>
4000f554: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4000f558: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
4000f55c: 80 a0 60 00 cmp %g1, 0
4000f560: 02 80 00 10 be 4000f5a0 <_Thread_Handler+0x9c>
4000f564: 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 ) {
4000f568: 22 80 00 13 be,a 4000f5b4 <_Thread_Handler+0xb0> <== ALWAYS TAKEN
4000f56c: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
4000f570: 90 10 00 1d mov %i5, %o0
4000f574: 13 10 00 2a sethi %hi(0x4000a800), %o1
4000f578: 7f ff ed 4c call 4000aaa8 <_User_extensions_Iterate>
4000f57c: 92 12 62 58 or %o1, 0x258, %o1 ! 4000aa58 <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
4000f580: 90 10 20 00 clr %o0
4000f584: 92 10 20 01 mov 1, %o1
4000f588: 7f ff e4 e1 call 4000890c <_Internal_error_Occurred>
4000f58c: 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 ();
4000f590: 40 00 3b 42 call 4001e298 <_init>
4000f594: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4000f598: 10 bf ff f1 b 4000f55c <_Thread_Handler+0x58>
4000f59c: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4000f5a0: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
4000f5a4: 9f c0 40 00 call %g1
4000f5a8: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
4000f5ac: 10 bf ff f1 b 4000f570 <_Thread_Handler+0x6c>
4000f5b0: 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)(
4000f5b4: 9f c0 40 00 call %g1
4000f5b8: 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 =
4000f5bc: 10 bf ff ed b 4000f570 <_Thread_Handler+0x6c>
4000f5c0: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
4000a180 <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
4000a180: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
4000a184: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000a188: 82 10 60 18 or %g1, 0x18, %g1 ! 4001c418 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000a18c: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
4000a190: fa 00 60 14 ld [ %g1 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
4000a194: 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 ||
4000a198: 80 a0 e0 00 cmp %g3, 0
4000a19c: 02 80 00 1f be 4000a218 <_Thread_Handler_initialization+0x98><== NEVER TAKEN
4000a1a0: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000a1a4: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
4000a1a8: 80 a0 e0 00 cmp %g3, 0
4000a1ac: 02 80 00 1b be 4000a218 <_Thread_Handler_initialization+0x98>
4000a1b0: 80 a0 a0 00 cmp %g2, 0
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
4000a1b4: 22 80 00 05 be,a 4000a1c8 <_Thread_Handler_initialization+0x48>
4000a1b8: 03 10 00 7c sethi %hi(0x4001f000), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000a1bc: 9f c0 80 00 call %g2
4000a1c0: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 4001f004 <_CPU_Null_fp_context+0x14>
_Thread_Dispatch_necessary = false;
4000a1c4: 03 10 00 7c sethi %hi(0x4001f000), %g1
4000a1c8: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 4001f3d0 <_Per_CPU_Information>
4000a1cc: c0 28 60 0c clrb [ %g1 + 0xc ]
_Thread_Executing = NULL;
4000a1d0: c0 20 60 10 clr [ %g1 + 0x10 ]
_Thread_Heir = NULL;
4000a1d4: 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;
4000a1d8: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000a1dc: f8 20 63 3c st %i4, [ %g1 + 0x33c ] ! 4001ef3c <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
4000a1e0: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000a1e4: fa 20 62 20 st %i5, [ %g1 + 0x220 ] ! 4001ee20 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
4000a1e8: 82 10 20 08 mov 8, %g1
4000a1ec: 11 10 00 7b sethi %hi(0x4001ec00), %o0
4000a1f0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000a1f4: 90 12 23 b0 or %o0, 0x3b0, %o0
4000a1f8: 92 10 20 01 mov 1, %o1
4000a1fc: 94 10 20 01 mov 1, %o2
4000a200: 96 10 20 01 mov 1, %o3
4000a204: 98 10 21 60 mov 0x160, %o4
4000a208: 7f ff fb 6a call 40008fb0 <_Objects_Initialize_information>
4000a20c: 9a 10 20 00 clr %o5
4000a210: 81 c7 e0 08 ret
4000a214: 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(
4000a218: 90 10 20 00 clr %o0
4000a21c: 92 10 20 01 mov 1, %o1
4000a220: 7f ff f9 bb call 4000890c <_Internal_error_Occurred>
4000a224: 94 10 20 0e mov 0xe, %o2
40009fa4 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
40009fa4: 9d e3 bf 98 save %sp, -104, %sp
40009fa8: 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;
40009fac: c0 26 61 4c clr [ %i1 + 0x14c ]
40009fb0: c0 26 61 50 clr [ %i1 + 0x150 ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
40009fb4: 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
)
{
40009fb8: f8 07 a0 60 ld [ %fp + 0x60 ], %i4
40009fbc: 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 ) {
40009fc0: 80 a6 a0 00 cmp %i2, 0
40009fc4: 02 80 00 60 be 4000a144 <_Thread_Initialize+0x1a0>
40009fc8: 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;
40009fcc: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
40009fd0: 90 10 00 1b mov %i3, %o0
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
40009fd4: 37 10 00 7b sethi %hi(0x4001ec00), %i3
40009fd8: c2 06 e3 3c ld [ %i3 + 0x33c ], %g1 ! 4001ef3c <_Thread_Maximum_extensions>
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
40009fdc: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
40009fe0: d0 26 60 b4 st %o0, [ %i1 + 0xb4 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40009fe4: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
40009fe8: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
40009fec: c0 26 60 68 clr [ %i1 + 0x68 ]
40009ff0: 80 a0 60 00 cmp %g1, 0
40009ff4: 12 80 00 40 bne 4000a0f4 <_Thread_Initialize+0x150>
40009ff8: c0 26 60 6c clr [ %i1 + 0x6c ]
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
40009ffc: 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;
4000a000: 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;
4000a004: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
4000a008: e2 2e 60 9c stb %l1, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
4000a00c: f8 26 60 a0 st %i4, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
4000a010: 80 a7 20 02 cmp %i4, 2
4000a014: 12 80 00 05 bne 4000a028 <_Thread_Initialize+0x84>
4000a018: 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;
4000a01c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000a020: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 4001ee20 <_Thread_Ticks_per_timeslice>
4000a024: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
4000a028: c4 07 a0 68 ld [ %fp + 0x68 ], %g2
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
4000a02c: 03 10 00 78 sethi %hi(0x4001e000), %g1
4000a030: c2 00 63 7c ld [ %g1 + 0x37c ], %g1 ! 4001e37c <_Scheduler+0x18>
4000a034: c4 26 60 a8 st %g2, [ %i1 + 0xa8 ]
the_thread->current_state = STATES_DORMANT;
4000a038: b6 10 20 01 mov 1, %i3
the_thread->Wait.queue = NULL;
4000a03c: c0 26 60 44 clr [ %i1 + 0x44 ]
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
4000a040: f6 26 60 10 st %i3, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
4000a044: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
4000a048: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
4000a04c: fa 26 60 ac st %i5, [ %i1 + 0xac ]
4000a050: 9f c0 40 00 call %g1
4000a054: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
4000a058: b8 92 20 00 orcc %o0, 0, %i4
4000a05c: 22 80 00 17 be,a 4000a0b8 <_Thread_Initialize+0x114>
4000a060: d0 06 61 48 ld [ %i1 + 0x148 ], %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
4000a064: 90 10 00 19 mov %i1, %o0
4000a068: 40 00 01 e0 call 4000a7e8 <_Thread_Set_priority>
4000a06c: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000a070: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
4000a074: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
4000a078: c0 26 60 80 clr [ %i1 + 0x80 ]
4000a07c: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000a080: 83 28 60 02 sll %g1, 2, %g1
4000a084: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000a088: 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 };
4000a08c: f2 27 bf f8 st %i1, [ %fp + -8 ]
4000a090: f6 2f bf fc stb %i3, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
4000a094: 90 07 bf f8 add %fp, -8, %o0
4000a098: 13 10 00 2a sethi %hi(0x4000a800), %o1
4000a09c: 40 00 02 83 call 4000aaa8 <_User_extensions_Iterate>
4000a0a0: 92 12 61 80 or %o1, 0x180, %o1 ! 4000a980 <_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 )
4000a0a4: c2 0f bf fc ldub [ %fp + -4 ], %g1
4000a0a8: 80 a0 60 00 cmp %g1, 0
4000a0ac: 12 80 00 0f bne 4000a0e8 <_Thread_Initialize+0x144>
4000a0b0: b0 10 20 01 mov 1, %i0
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
4000a0b4: d0 06 61 48 ld [ %i1 + 0x148 ], %o0
4000a0b8: 40 00 03 dd call 4000b02c <_Workspace_Free>
4000a0bc: b0 10 20 00 clr %i0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
4000a0c0: 40 00 03 db call 4000b02c <_Workspace_Free>
4000a0c4: d0 06 61 4c ld [ %i1 + 0x14c ], %o0
4000a0c8: 40 00 03 d9 call 4000b02c <_Workspace_Free>
4000a0cc: d0 06 61 50 ld [ %i1 + 0x150 ], %o0
_Workspace_Free( extensions_area );
4000a0d0: 40 00 03 d7 call 4000b02c <_Workspace_Free>
4000a0d4: 90 10 00 1a mov %i2, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
#endif
_Workspace_Free( sched );
4000a0d8: 40 00 03 d5 call 4000b02c <_Workspace_Free>
4000a0dc: 90 10 00 1c mov %i4, %o0
_Thread_Stack_Free( the_thread );
4000a0e0: 40 00 01 fb call 4000a8cc <_Thread_Stack_Free>
4000a0e4: 90 10 00 19 mov %i1, %o0
4000a0e8: b0 0e 20 ff and %i0, 0xff, %i0
4000a0ec: 81 c7 e0 08 ret
4000a0f0: 81 e8 00 00 restore
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
4000a0f4: 90 00 60 01 add %g1, 1, %o0
4000a0f8: 40 00 03 c5 call 4000b00c <_Workspace_Allocate>
4000a0fc: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
4000a100: b4 92 20 00 orcc %o0, 0, %i2
4000a104: 02 80 00 1d be 4000a178 <_Thread_Initialize+0x1d4>
4000a108: 86 10 00 1a mov %i2, %g3
goto failed;
}
the_thread->extensions = (void **) extensions_area;
4000a10c: f4 26 61 54 st %i2, [ %i1 + 0x154 ]
4000a110: c8 06 e3 3c ld [ %i3 + 0x33c ], %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++ )
4000a114: 84 10 20 00 clr %g2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
4000a118: 10 80 00 03 b 4000a124 <_Thread_Initialize+0x180>
4000a11c: 82 10 20 00 clr %g1
4000a120: 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;
4000a124: 85 28 a0 02 sll %g2, 2, %g2
4000a128: 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++ )
4000a12c: 82 00 60 01 inc %g1
4000a130: 80 a0 40 04 cmp %g1, %g4
4000a134: 08 bf ff fb bleu 4000a120 <_Thread_Initialize+0x17c>
4000a138: 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;
4000a13c: 10 bf ff b3 b 4000a008 <_Thread_Initialize+0x64>
4000a140: 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 );
4000a144: 90 10 00 19 mov %i1, %o0
4000a148: 40 00 01 d1 call 4000a88c <_Thread_Stack_Allocate>
4000a14c: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
4000a150: 80 a2 00 1b cmp %o0, %i3
4000a154: 0a 80 00 07 bcs 4000a170 <_Thread_Initialize+0x1cc>
4000a158: 80 a2 20 00 cmp %o0, 0
4000a15c: 02 80 00 05 be 4000a170 <_Thread_Initialize+0x1cc> <== NEVER TAKEN
4000a160: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
4000a164: f4 06 60 bc ld [ %i1 + 0xbc ], %i2
the_thread->Start.core_allocated_stack = true;
4000a168: 10 bf ff 9b b 40009fd4 <_Thread_Initialize+0x30>
4000a16c: 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 */
4000a170: 10 bf ff de b 4000a0e8 <_Thread_Initialize+0x144>
4000a174: 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;
4000a178: 10 bf ff cf b 4000a0b4 <_Thread_Initialize+0x110>
4000a17c: b8 10 20 00 clr %i4
4000a8cc <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000a8cc: 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 )
4000a8d0: c2 0e 20 b0 ldub [ %i0 + 0xb0 ], %g1
4000a8d4: 80 a0 60 00 cmp %g1, 0
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
4000a8d8: 03 10 00 71 sethi %hi(0x4001c400), %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 )
4000a8dc: 02 80 00 04 be 4000a8ec <_Thread_Stack_Free+0x20> <== NEVER TAKEN
4000a8e0: c2 00 60 44 ld [ %g1 + 0x44 ], %g1 ! 4001c444 <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 );
4000a8e4: 9f c0 40 00 call %g1
4000a8e8: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
4000a8ec: 81 c7 e0 08 ret
4000a8f0: 81 e8 00 00 restore
4000f5c4 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4000f5c4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
4000f5c8: 7f ff ca b7 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
4000f5cc: 01 00 00 00 nop <== NOT EXECUTED
4000f5d0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000f5d4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED
4000f5d8: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
4000f5dc: 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 ) ) {
4000f5e0: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
4000f5e4: 02 80 00 1a be 4000f64c <_Thread_queue_Extract_fifo+0x88> <== NOT EXECUTED
4000f5e8: 01 00 00 00 nop <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000f5ec: c4 06 40 00 ld [ %i1 ], %g2 <== NOT EXECUTED
previous = the_node->previous;
4000f5f0: 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 ) ) {
4000f5f4: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 <== NOT EXECUTED
next->previous = previous;
4000f5f8: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000f5fc: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
4000f600: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED
4000f604: 02 80 00 08 be 4000f624 <_Thread_queue_Extract_fifo+0x60> <== NOT EXECUTED
4000f608: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED
_ISR_Enable( level );
4000f60c: 7f ff ca aa call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
4000f610: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
4000f614: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
4000f618: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4000f61c: 7f ff e9 3e call 40009b14 <_Thread_Clear_state> <== NOT EXECUTED
4000f620: 81 e8 00 00 restore <== NOT EXECUTED
4000f624: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
4000f628: c2 26 60 50 st %g1, [ %i1 + 0x50 ] <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4000f62c: 7f ff ca a2 call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
4000f630: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4000f634: 7f ff ed c0 call 4000ad34 <_Watchdog_Remove> <== NOT EXECUTED
4000f638: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED
4000f63c: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
4000f640: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4000f644: 7f ff e9 34 call 40009b14 <_Thread_Clear_state> <== NOT EXECUTED
4000f648: 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 );
4000f64c: 7f ff ca 9a call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
4000f650: 81 e8 00 00 restore <== NOT EXECUTED
4000a728 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
4000a728: 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 )
4000a72c: 80 a6 20 00 cmp %i0, 0
4000a730: 02 80 00 13 be 4000a77c <_Thread_queue_Requeue+0x54> <== NEVER TAKEN
4000a734: 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 ) {
4000a738: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
4000a73c: 80 a7 60 01 cmp %i5, 1
4000a740: 02 80 00 04 be 4000a750 <_Thread_queue_Requeue+0x28> <== ALWAYS TAKEN
4000a744: 01 00 00 00 nop
4000a748: 81 c7 e0 08 ret <== NOT EXECUTED
4000a74c: 81 e8 00 00 restore <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
4000a750: 7f ff de 55 call 400020a4 <sparc_disable_interrupts>
4000a754: 01 00 00 00 nop
4000a758: b8 10 00 08 mov %o0, %i4
4000a75c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4000a760: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000a764: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000a768: 80 88 80 01 btst %g2, %g1
4000a76c: 12 80 00 06 bne 4000a784 <_Thread_queue_Requeue+0x5c> <== ALWAYS TAKEN
4000a770: 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 );
4000a774: 7f ff de 50 call 400020b4 <sparc_enable_interrupts>
4000a778: 90 10 00 1c mov %i4, %o0
4000a77c: 81 c7 e0 08 ret
4000a780: 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 );
4000a784: 92 10 00 19 mov %i1, %o1
4000a788: 94 10 20 01 mov 1, %o2
4000a78c: 40 00 0c 98 call 4000d9ec <_Thread_queue_Extract_priority_helper>
4000a790: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000a794: 90 10 00 18 mov %i0, %o0
4000a798: 92 10 00 19 mov %i1, %o1
4000a79c: 7f ff ff 35 call 4000a470 <_Thread_queue_Enqueue_priority>
4000a7a0: 94 07 bf fc add %fp, -4, %o2
4000a7a4: 30 bf ff f4 b,a 4000a774 <_Thread_queue_Requeue+0x4c>
4000a7a8 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4000a7a8: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000a7ac: 90 10 00 18 mov %i0, %o0
4000a7b0: 7f ff fd d2 call 40009ef8 <_Thread_Get>
4000a7b4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000a7b8: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a7bc: 80 a0 60 00 cmp %g1, 0
4000a7c0: 12 80 00 08 bne 4000a7e0 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
4000a7c4: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000a7c8: 40 00 0c c2 call 4000dad0 <_Thread_queue_Process_timeout>
4000a7cc: 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;
4000a7d0: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000a7d4: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 4001eec0 <_Thread_Dispatch_disable_level>
--level;
4000a7d8: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000a7dc: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
4000a7e0: 81 c7 e0 08 ret
4000a7e4: 81 e8 00 00 restore
400178f0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
400178f0: 9d e3 bf 88 save %sp, -120, %sp
400178f4: 21 10 00 f5 sethi %hi(0x4003d400), %l0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400178f8: a4 07 bf e8 add %fp, -24, %l2
400178fc: b4 07 bf ec add %fp, -20, %i2
40017900: b8 07 bf f4 add %fp, -12, %i4
40017904: a2 07 bf f8 add %fp, -8, %l1
40017908: 33 10 00 f4 sethi %hi(0x4003d000), %i1
4001790c: 27 10 00 f5 sethi %hi(0x4003d400), %l3
40017910: f4 27 bf e8 st %i2, [ %fp + -24 ]
head->previous = NULL;
40017914: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
40017918: 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;
4001791c: e2 27 bf f4 st %l1, [ %fp + -12 ]
head->previous = NULL;
40017920: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
40017924: f8 27 bf fc st %i4, [ %fp + -4 ]
40017928: a0 14 21 58 or %l0, 0x158, %l0
4001792c: b6 06 20 30 add %i0, 0x30, %i3
40017930: b2 16 63 b8 or %i1, 0x3b8, %i1
40017934: ba 06 20 68 add %i0, 0x68, %i5
40017938: a6 14 e0 70 or %l3, 0x70, %l3
4001793c: ac 06 20 08 add %i0, 8, %l6
40017940: 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;
40017944: 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;
40017948: 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;
4001794c: c2 04 00 00 ld [ %l0 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
40017950: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40017954: 90 10 00 1b mov %i3, %o0
40017958: 92 20 40 09 sub %g1, %o1, %o1
4001795c: 94 10 00 1c mov %i4, %o2
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
40017960: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40017964: 40 00 12 35 call 4001c238 <_Watchdog_Adjust_to_chain>
40017968: 01 00 00 00 nop
4001796c: d0 1e 40 00 ldd [ %i1 ], %o0
40017970: 94 10 20 00 clr %o2
40017974: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40017978: 40 00 51 6b call 4002bf24 <__divdi3>
4001797c: 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;
40017980: 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 ) {
40017984: 80 a2 40 0a cmp %o1, %o2
40017988: 18 80 00 2b bgu 40017a34 <_Timer_server_Body+0x144>
4001798c: 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 ) {
40017990: 80 a2 40 0a cmp %o1, %o2
40017994: 0a 80 00 20 bcs 40017a14 <_Timer_server_Body+0x124>
40017998: 90 10 00 1d mov %i5, %o0
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
4001799c: 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 );
400179a0: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
400179a4: 40 00 02 c2 call 400184ac <_Chain_Get>
400179a8: 01 00 00 00 nop
if ( timer == NULL ) {
400179ac: 92 92 20 00 orcc %o0, 0, %o1
400179b0: 02 80 00 10 be 400179f0 <_Timer_server_Body+0x100>
400179b4: 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 ) {
400179b8: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
400179bc: 80 a0 60 01 cmp %g1, 1
400179c0: 02 80 00 19 be 40017a24 <_Timer_server_Body+0x134>
400179c4: 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 ) {
400179c8: 12 bf ff f6 bne 400179a0 <_Timer_server_Body+0xb0> <== NEVER TAKEN
400179cc: 92 02 60 10 add %o1, 0x10, %o1
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
400179d0: 40 00 12 46 call 4001c2e8 <_Watchdog_Insert>
400179d4: 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 );
400179d8: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
400179dc: 40 00 02 b4 call 400184ac <_Chain_Get>
400179e0: 01 00 00 00 nop
if ( timer == NULL ) {
400179e4: 92 92 20 00 orcc %o0, 0, %o1
400179e8: 32 bf ff f5 bne,a 400179bc <_Timer_server_Body+0xcc> <== NEVER TAKEN
400179ec: 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 );
400179f0: 7f ff dd e8 call 4000f190 <sparc_disable_interrupts>
400179f4: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
400179f8: c2 07 bf e8 ld [ %fp + -24 ], %g1
400179fc: 80 a0 40 1a cmp %g1, %i2
40017a00: 02 80 00 12 be 40017a48 <_Timer_server_Body+0x158> <== ALWAYS TAKEN
40017a04: 01 00 00 00 nop
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
40017a08: 7f ff dd e6 call 4000f1a0 <sparc_enable_interrupts> <== NOT EXECUTED
40017a0c: 01 00 00 00 nop <== NOT EXECUTED
40017a10: 30 bf ff cf b,a 4001794c <_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 );
40017a14: 92 10 20 01 mov 1, %o1 ! 1 <PROM_START+0x1>
40017a18: 40 00 11 d8 call 4001c178 <_Watchdog_Adjust>
40017a1c: 94 22 80 17 sub %o2, %l7, %o2
40017a20: 30 bf ff df b,a 4001799c <_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 );
40017a24: 90 10 00 1b mov %i3, %o0
40017a28: 40 00 12 30 call 4001c2e8 <_Watchdog_Insert>
40017a2c: 92 02 60 10 add %o1, 0x10, %o1
40017a30: 30 bf ff dc b,a 400179a0 <_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 );
40017a34: 92 22 40 0a sub %o1, %o2, %o1
40017a38: 90 10 00 1d mov %i5, %o0
40017a3c: 40 00 11 ff call 4001c238 <_Watchdog_Adjust_to_chain>
40017a40: 94 10 00 1c mov %i4, %o2
40017a44: 30 bf ff d6 b,a 4001799c <_Timer_server_Body+0xac>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
40017a48: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
40017a4c: 7f ff dd d5 call 4000f1a0 <sparc_enable_interrupts>
40017a50: 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 ) ) {
40017a54: c2 07 bf f4 ld [ %fp + -12 ], %g1
40017a58: 80 a0 40 11 cmp %g1, %l1
40017a5c: 12 80 00 0c bne 40017a8c <_Timer_server_Body+0x19c>
40017a60: 01 00 00 00 nop
40017a64: 30 80 00 13 b,a 40017ab0 <_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;
40017a68: 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;
40017a6c: 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;
40017a70: c0 25 e0 08 clr [ %l7 + 8 ]
_ISR_Enable( level );
40017a74: 7f ff dd cb call 4000f1a0 <sparc_enable_interrupts>
40017a78: 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 );
40017a7c: d0 05 e0 20 ld [ %l7 + 0x20 ], %o0
40017a80: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1
40017a84: 9f c0 40 00 call %g1
40017a88: 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 );
40017a8c: 7f ff dd c1 call 4000f190 <sparc_disable_interrupts>
40017a90: 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;
40017a94: 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))
40017a98: 80 a5 c0 11 cmp %l7, %l1
40017a9c: 32 bf ff f3 bne,a 40017a68 <_Timer_server_Body+0x178>
40017aa0: 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 );
40017aa4: 7f ff dd bf call 4000f1a0 <sparc_enable_interrupts>
40017aa8: 01 00 00 00 nop
40017aac: 30 bf ff a7 b,a 40017948 <_Timer_server_Body+0x58>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
40017ab0: 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;
40017ab4: c2 04 c0 00 ld [ %l3 ], %g1
++level;
40017ab8: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
40017abc: c2 24 c0 00 st %g1, [ %l3 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
40017ac0: d0 06 00 00 ld [ %i0 ], %o0
40017ac4: 40 00 10 c1 call 4001bdc8 <_Thread_Set_state>
40017ac8: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
40017acc: 7f ff ff 07 call 400176e8 <_Timer_server_Reset_interval_system_watchdog>
40017ad0: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
40017ad4: 7f ff ff 19 call 40017738 <_Timer_server_Reset_tod_system_watchdog>
40017ad8: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
40017adc: 40 00 0e 4d call 4001b410 <_Thread_Enable_dispatch>
40017ae0: 01 00 00 00 nop
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
40017ae4: 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;
40017ae8: 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 );
40017aec: 40 00 12 5e call 4001c464 <_Watchdog_Remove>
40017af0: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
40017af4: 40 00 12 5c call 4001c464 <_Watchdog_Remove>
40017af8: 90 10 00 15 mov %l5, %o0
40017afc: 30 bf ff 93 b,a 40017948 <_Timer_server_Body+0x58>
40017788 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
40017788: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
4001778c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
40017790: 80 a0 60 00 cmp %g1, 0
40017794: 02 80 00 05 be 400177a8 <_Timer_server_Schedule_operation_method+0x20>
40017798: 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 );
4001779c: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
400177a0: 40 00 03 38 call 40018480 <_Chain_Append>
400177a4: 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;
400177a8: 03 10 00 f5 sethi %hi(0x4003d400), %g1
400177ac: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 ! 4003d470 <_Thread_Dispatch_disable_level>
++level;
400177b0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400177b4: c4 20 60 70 st %g2, [ %g1 + 0x70 ]
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
400177b8: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
400177bc: 80 a0 60 01 cmp %g1, 1
400177c0: 02 80 00 2b be 4001786c <_Timer_server_Schedule_operation_method+0xe4>
400177c4: 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 ) {
400177c8: 02 80 00 04 be 400177d8 <_Timer_server_Schedule_operation_method+0x50>
400177cc: 01 00 00 00 nop
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
400177d0: 40 00 0f 10 call 4001b410 <_Thread_Enable_dispatch>
400177d4: 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 );
400177d8: 7f ff de 6e call 4000f190 <sparc_disable_interrupts>
400177dc: 01 00 00 00 nop
400177e0: b8 10 00 08 mov %o0, %i4
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
400177e4: 03 10 00 f4 sethi %hi(0x4003d000), %g1
400177e8: d0 18 63 b8 ldd [ %g1 + 0x3b8 ], %o0 ! 4003d3b8 <_TOD>
400177ec: 94 10 20 00 clr %o2
400177f0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400177f4: 40 00 51 cc call 4002bf24 <__divdi3>
400177f8: 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;
400177fc: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
40017800: 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 );
40017804: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
40017808: 80 a0 40 03 cmp %g1, %g3
4001780c: 02 80 00 0a be 40017834 <_Timer_server_Schedule_operation_method+0xac>
40017810: 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 ) {
40017814: 08 80 00 34 bleu 400178e4 <_Timer_server_Schedule_operation_method+0x15c>
40017818: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
4001781c: 84 22 40 02 sub %o1, %g2, %g2
if (delta_interval > delta) {
40017820: 80 a1 00 02 cmp %g4, %g2
40017824: 08 80 00 03 bleu 40017830 <_Timer_server_Schedule_operation_method+0xa8><== NEVER TAKEN
40017828: 86 10 20 00 clr %g3
delta_interval -= delta;
4001782c: 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;
40017830: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
40017834: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
40017838: 7f ff de 5a call 4000f1a0 <sparc_enable_interrupts>
4001783c: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
40017840: 90 06 20 68 add %i0, 0x68, %o0
40017844: 40 00 12 a9 call 4001c2e8 <_Watchdog_Insert>
40017848: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
4001784c: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
40017850: 80 a0 60 00 cmp %g1, 0
40017854: 12 bf ff df bne 400177d0 <_Timer_server_Schedule_operation_method+0x48>
40017858: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
4001785c: 7f ff ff b7 call 40017738 <_Timer_server_Reset_tod_system_watchdog>
40017860: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
40017864: 40 00 0e eb call 4001b410 <_Thread_Enable_dispatch>
40017868: 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 );
4001786c: 7f ff de 49 call 4000f190 <sparc_disable_interrupts>
40017870: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
40017874: 05 10 00 f5 sethi %hi(0x4003d400), %g2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
40017878: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4001787c: c4 00 a1 58 ld [ %g2 + 0x158 ], %g2
last_snapshot = ts->Interval_watchdogs.last_snapshot;
40017880: 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 );
40017884: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
40017888: 80 a0 40 03 cmp %g1, %g3
4001788c: 02 80 00 08 be 400178ac <_Timer_server_Schedule_operation_method+0x124>
40017890: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
40017894: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
40017898: 80 a1 00 1c cmp %g4, %i4
4001789c: 1a 80 00 03 bcc 400178a8 <_Timer_server_Schedule_operation_method+0x120>
400178a0: 86 10 20 00 clr %g3
delta_interval -= delta;
400178a4: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
400178a8: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
400178ac: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
400178b0: 7f ff de 3c call 4000f1a0 <sparc_enable_interrupts>
400178b4: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
400178b8: 90 06 20 30 add %i0, 0x30, %o0
400178bc: 40 00 12 8b call 4001c2e8 <_Watchdog_Insert>
400178c0: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
400178c4: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
400178c8: 80 a0 60 00 cmp %g1, 0
400178cc: 12 bf ff c1 bne 400177d0 <_Timer_server_Schedule_operation_method+0x48>
400178d0: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
400178d4: 7f ff ff 85 call 400176e8 <_Timer_server_Reset_interval_system_watchdog>
400178d8: 90 10 00 18 mov %i0, %o0
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
400178dc: 40 00 0e cd call 4001b410 <_Thread_Enable_dispatch>
400178e0: 81 e8 00 00 restore
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
400178e4: 84 01 00 02 add %g4, %g2, %g2
delta_interval += delta;
400178e8: 10 bf ff d2 b 40017830 <_Timer_server_Schedule_operation_method+0xa8>
400178ec: 86 20 80 09 sub %g2, %o1, %g3
4000c498 <_Timespec_Add_to>:
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
4000c498: 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;
4000c49c: c4 02 40 00 ld [ %o1 ], %g2
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
4000c4a0: c6 02 20 04 ld [ %o0 + 4 ], %g3
4000c4a4: c2 02 60 04 ld [ %o1 + 4 ], %g1
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
4000c4a8: 98 03 00 02 add %o4, %g2, %o4
time->tv_nsec += add->tv_nsec;
4000c4ac: 82 00 c0 01 add %g3, %g1, %g1
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
4000c4b0: 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 ) {
4000c4b4: 09 0e e6 b2 sethi %hi(0x3b9ac800), %g4
4000c4b8: 88 11 21 ff or %g4, 0x1ff, %g4 ! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000c4bc: 80 a0 40 04 cmp %g1, %g4
4000c4c0: 08 80 00 0d bleu 4000c4f4 <_Timespec_Add_to+0x5c>
4000c4c4: c2 22 20 04 st %g1, [ %o0 + 4 ]
4000c4c8: 98 03 20 01 inc %o4
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000c4cc: 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(
4000c4d0: 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;
4000c4d4: 9a 13 62 00 or %o5, 0x200, %o5
4000c4d8: 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(
4000c4dc: 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 ) {
4000c4e0: 80 a0 40 04 cmp %g1, %g4
4000c4e4: 18 bf ff fd bgu 4000c4d8 <_Timespec_Add_to+0x40> <== NEVER TAKEN
4000c4e8: 84 00 a0 01 inc %g2
4000c4ec: c2 22 20 04 st %g1, [ %o0 + 4 ]
4000c4f0: c6 22 00 00 st %g3, [ %o0 ]
time->tv_sec++;
seconds++;
}
return seconds;
}
4000c4f4: 81 c3 e0 08 retl
4000c4f8: 90 10 00 02 mov %g2, %o0
4000c230 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
4000c230: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
4000c234: d4 1e 40 00 ldd [ %i1 ], %o2
4000c238: 80 92 80 0b orcc %o2, %o3, %g0
4000c23c: 22 80 00 2f be,a 4000c2f8 <_Timestamp64_Divide+0xc8> <== NEVER TAKEN
4000c240: 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;
4000c244: e0 1e 00 00 ldd [ %i0 ], %l0
4000c248: 83 2c 20 02 sll %l0, 2, %g1
4000c24c: 89 34 60 1e srl %l1, 0x1e, %g4
4000c250: 87 2c 60 02 sll %l1, 2, %g3
4000c254: 84 11 00 01 or %g4, %g1, %g2
4000c258: 83 30 e0 1b srl %g3, 0x1b, %g1
4000c25c: 9b 28 e0 05 sll %g3, 5, %o5
4000c260: 99 28 a0 05 sll %g2, 5, %o4
4000c264: 86 a3 40 03 subcc %o5, %g3, %g3
4000c268: 98 10 40 0c or %g1, %o4, %o4
4000c26c: 84 63 00 02 subx %o4, %g2, %g2
4000c270: 92 80 c0 11 addcc %g3, %l1, %o1
4000c274: 83 32 60 1e srl %o1, 0x1e, %g1
4000c278: 90 40 80 10 addx %g2, %l0, %o0
4000c27c: b3 2a 60 02 sll %o1, 2, %i1
4000c280: b1 2a 20 02 sll %o0, 2, %i0
4000c284: 86 82 40 19 addcc %o1, %i1, %g3
4000c288: b0 10 40 18 or %g1, %i0, %i0
4000c28c: 83 30 e0 1e srl %g3, 0x1e, %g1
4000c290: 84 42 00 18 addx %o0, %i0, %g2
4000c294: bb 28 e0 02 sll %g3, 2, %i5
4000c298: b9 28 a0 02 sll %g2, 2, %i4
4000c29c: 92 80 c0 1d addcc %g3, %i5, %o1
4000c2a0: b8 10 40 1c or %g1, %i4, %i4
4000c2a4: 87 32 60 1b srl %o1, 0x1b, %g3
4000c2a8: 90 40 80 1c addx %g2, %i4, %o0
4000c2ac: 83 2a 60 05 sll %o1, 5, %g1
4000c2b0: 85 2a 20 05 sll %o0, 5, %g2
4000c2b4: 92 10 00 01 mov %g1, %o1
4000c2b8: 40 00 3b 32 call 4001af80 <__divdi3>
4000c2bc: 90 10 c0 02 or %g3, %g2, %o0
*_ival_percentage = answer / 1000;
4000c2c0: 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;
4000c2c4: b8 10 00 08 mov %o0, %i4
4000c2c8: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
4000c2cc: 40 00 3b 2d call 4001af80 <__divdi3>
4000c2d0: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
4000c2d4: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
4000c2d8: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
4000c2dc: 94 10 20 00 clr %o2
4000c2e0: 96 10 23 e8 mov 0x3e8, %o3
4000c2e4: 40 00 3c 12 call 4001b32c <__moddi3>
4000c2e8: 92 10 00 1d mov %i5, %o1
4000c2ec: d2 26 c0 00 st %o1, [ %i3 ]
4000c2f0: 81 c7 e0 08 ret
4000c2f4: 81 e8 00 00 restore
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
*_ival_percentage = 0;
*_fval_percentage = 0;
4000c2f8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
4000c2fc: 81 c7 e0 08 ret <== NOT EXECUTED
4000c300: 81 e8 00 00 restore <== NOT EXECUTED
4000ab78 <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
4000ab78: 9d e3 bf 98 save %sp, -104, %sp
uint32_t number_of_initial_extensions =
4000ab7c: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000ab80: c2 00 60 58 ld [ %g1 + 0x58 ], %g1 ! 4001c458 <Configuration+0x40>
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
4000ab84: 80 a0 60 00 cmp %g1, 0
4000ab88: 02 80 00 0a be 4000abb0 <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
4000ab8c: 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 )
4000ab90: 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 =
4000ab94: 40 00 01 2c call 4000b044 <_Workspace_Allocate_or_fatal_error>
4000ab98: 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 );
4000ab9c: 13 10 00 2a sethi %hi(0x4000a800), %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 };
4000aba0: d0 27 bf fc st %o0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000aba4: 92 12 63 34 or %o1, 0x334, %o1
4000aba8: 7f ff ff c0 call 4000aaa8 <_User_extensions_Iterate>
4000abac: 90 07 bf fc add %fp, -4, %o0
4000abb0: 81 c7 e0 08 ret
4000abb4: 81 e8 00 00 restore
4000aaa8 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
4000aaa8: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
4000aaac: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000aab0: 82 10 60 18 or %g1, 0x18, %g1 ! 4001c418 <Configuration>
4000aab4: 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();
4000aab8: f6 00 60 40 ld [ %g1 + 0x40 ], %i3
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
Thread_Control *executing = _Thread_Executing;
4000aabc: 03 10 00 7c sethi %hi(0x4001f000), %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();
4000aac0: 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 =
4000aac4: 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 ) {
4000aac8: 80 a7 40 1b cmp %i5, %i3
4000aacc: 02 80 00 0a be 4000aaf4 <_User_extensions_Iterate+0x4c> <== NEVER TAKEN
4000aad0: f8 00 63 e0 ld [ %g1 + 0x3e0 ], %i4
(*visitor)( executing, arg, callouts_current );
4000aad4: 94 10 00 1d mov %i5, %o2
4000aad8: 90 10 00 1c mov %i4, %o0
4000aadc: 9f c6 40 00 call %i1
4000aae0: 92 10 00 18 mov %i0, %o1
++callouts_current;
4000aae4: 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 ) {
4000aae8: 80 a6 c0 1d cmp %i3, %i5
4000aaec: 12 bf ff fb bne 4000aad8 <_User_extensions_Iterate+0x30>
4000aaf0: 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;
4000aaf4: 37 10 00 79 sethi %hi(0x4001e400), %i3
4000aaf8: fa 06 e0 80 ld [ %i3 + 0x80 ], %i5 ! 4001e480 <_User_extensions_List>
4000aafc: b6 16 e0 80 or %i3, 0x80, %i3
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
4000ab00: b6 06 e0 04 add %i3, 4, %i3
4000ab04: 80 a7 40 1b cmp %i5, %i3
4000ab08: 02 80 00 09 be 4000ab2c <_User_extensions_Iterate+0x84>
4000ab0c: 94 07 60 14 add %i5, 0x14, %o2
const User_extensions_Control *extension =
(const User_extensions_Control *) node;
(*visitor)( executing, arg, &extension->Callouts );
4000ab10: 90 10 00 1c mov %i4, %o0
4000ab14: 9f c6 40 00 call %i1
4000ab18: 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;
4000ab1c: 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 ) {
4000ab20: 80 a7 40 1b cmp %i5, %i3
4000ab24: 12 bf ff fb bne 4000ab10 <_User_extensions_Iterate+0x68>
4000ab28: 94 07 60 14 add %i5, 0x14, %o2
4000ab2c: 81 c7 e0 08 ret
4000ab30: 81 e8 00 00 restore
4000c57c <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
4000c57c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
4000c580: 7f ff da 17 call 40002ddc <sparc_disable_interrupts>
4000c584: 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;
4000c588: 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 );
4000c58c: 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 ) ) {
4000c590: 80 a0 40 1c cmp %g1, %i4
4000c594: 02 80 00 1f be 4000c610 <_Watchdog_Adjust+0x94>
4000c598: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
4000c59c: 12 80 00 1f bne 4000c618 <_Watchdog_Adjust+0x9c>
4000c5a0: 80 a6 60 01 cmp %i1, 1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
4000c5a4: 80 a6 a0 00 cmp %i2, 0
4000c5a8: 02 80 00 1a be 4000c610 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
4000c5ac: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
4000c5b0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000c5b4: 80 a6 80 02 cmp %i2, %g2
4000c5b8: 1a 80 00 0a bcc 4000c5e0 <_Watchdog_Adjust+0x64> <== ALWAYS TAKEN
4000c5bc: b6 10 20 01 mov 1, %i3
_Watchdog_First( header )->delta_interval -= units;
4000c5c0: 10 80 00 1d b 4000c634 <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
4000c5c4: 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 ) {
4000c5c8: 02 80 00 12 be 4000c610 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
4000c5cc: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
4000c5d0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000c5d4: 80 a0 80 1a cmp %g2, %i2
4000c5d8: 38 80 00 17 bgu,a 4000c634 <_Watchdog_Adjust+0xb8>
4000c5dc: 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;
4000c5e0: 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;
4000c5e4: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
4000c5e8: 7f ff da 01 call 40002dec <sparc_enable_interrupts>
4000c5ec: 01 00 00 00 nop
_Watchdog_Tickle( header );
4000c5f0: 40 00 00 a8 call 4000c890 <_Watchdog_Tickle>
4000c5f4: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
4000c5f8: 7f ff d9 f9 call 40002ddc <sparc_disable_interrupts>
4000c5fc: 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;
4000c600: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
4000c604: 80 a7 00 01 cmp %i4, %g1
4000c608: 12 bf ff f0 bne 4000c5c8 <_Watchdog_Adjust+0x4c>
4000c60c: 80 a6 a0 00 cmp %i2, 0
}
break;
}
}
_ISR_Enable( level );
4000c610: 7f ff d9 f7 call 40002dec <sparc_enable_interrupts>
4000c614: 91 e8 00 08 restore %g0, %o0, %o0
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
4000c618: 12 bf ff fe bne 4000c610 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
4000c61c: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
4000c620: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000c624: b4 00 80 1a add %g2, %i2, %i2
4000c628: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
}
break;
}
}
_ISR_Enable( level );
4000c62c: 7f ff d9 f0 call 40002dec <sparc_enable_interrupts>
4000c630: 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;
4000c634: 10 bf ff f7 b 4000c610 <_Watchdog_Adjust+0x94>
4000c638: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4001c238 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
4001c238: 9d e3 bf a0 save %sp, -96, %sp
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
_ISR_Disable( level );
4001c23c: 7f ff cb d5 call 4000f190 <sparc_disable_interrupts>
4001c240: 01 00 00 00 nop
4001c244: c2 06 00 00 ld [ %i0 ], %g1
4001c248: ba 06 20 04 add %i0, 4, %i5
4001c24c: b8 06 a0 04 add %i2, 4, %i4
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
4001c250: 80 a7 40 01 cmp %i5, %g1
4001c254: 02 80 00 20 be 4001c2d4 <_Watchdog_Adjust_to_chain+0x9c>
4001c258: 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 ) {
4001c25c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001c260: 80 a6 40 02 cmp %i1, %g2
4001c264: 2a 80 00 1e bcs,a 4001c2dc <_Watchdog_Adjust_to_chain+0xa4>
4001c268: 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;
4001c26c: b2 26 40 02 sub %i1, %g2, %i1
first->delta_interval = 0;
4001c270: c0 20 60 10 clr [ %g1 + 0x10 ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4001c274: c4 00 60 04 ld [ %g1 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4001c278: c6 00 40 00 ld [ %g1 ], %g3
previous = the_node->previous;
next->previous = previous;
4001c27c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4001c280: 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;
4001c284: c4 06 a0 08 ld [ %i2 + 8 ], %g2
the_node->next = tail;
4001c288: f8 20 40 00 st %i4, [ %g1 ]
tail->previous = the_node;
4001c28c: c2 26 a0 08 st %g1, [ %i2 + 8 ]
old_last->next = the_node;
4001c290: c2 20 80 00 st %g1, [ %g2 ]
the_node->previous = old_last;
4001c294: 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 );
4001c298: 7f ff cb c2 call 4000f1a0 <sparc_enable_interrupts>
4001c29c: 01 00 00 00 nop
4001c2a0: 7f ff cb bc call 4000f190 <sparc_disable_interrupts>
4001c2a4: 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;
4001c2a8: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
4001c2ac: 80 a7 40 01 cmp %i5, %g1
4001c2b0: 02 bf ff e9 be 4001c254 <_Watchdog_Adjust_to_chain+0x1c>
4001c2b4: 01 00 00 00 nop
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
4001c2b8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001c2bc: 80 a0 a0 00 cmp %g2, 0
4001c2c0: 22 bf ff ee be,a 4001c278 <_Watchdog_Adjust_to_chain+0x40>
4001c2c4: c4 00 60 04 ld [ %g1 + 4 ], %g2
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
4001c2c8: 80 a7 40 01 cmp %i5, %g1
4001c2cc: 12 bf ff e6 bne 4001c264 <_Watchdog_Adjust_to_chain+0x2c> <== ALWAYS TAKEN
4001c2d0: 80 a6 40 02 cmp %i1, %g2
if ( first->delta_interval != 0 )
break;
}
}
_ISR_Enable( level );
4001c2d4: 7f ff cb b3 call 4000f1a0 <sparc_enable_interrupts>
4001c2d8: 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;
4001c2dc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( first->delta_interval != 0 )
break;
}
}
_ISR_Enable( level );
4001c2e0: 7f ff cb b0 call 4000f1a0 <sparc_enable_interrupts>
4001c2e4: 91 e8 00 08 restore %g0, %o0, %o0
4000ad34 <_Watchdog_Remove>:
#include <rtems/score/watchdog.h>
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
4000ad34: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
4000ad38: 7f ff dc db call 400020a4 <sparc_disable_interrupts>
4000ad3c: 01 00 00 00 nop
previous_state = the_watchdog->state;
4000ad40: fa 06 20 08 ld [ %i0 + 8 ], %i5
switch ( previous_state ) {
4000ad44: 80 a7 60 01 cmp %i5, 1
4000ad48: 02 80 00 2a be 4000adf0 <_Watchdog_Remove+0xbc>
4000ad4c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000ad50: 1a 80 00 09 bcc 4000ad74 <_Watchdog_Remove+0x40>
4000ad54: 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;
4000ad58: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000ad5c: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 4001efa8 <_Watchdog_Ticks_since_boot>
4000ad60: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
4000ad64: 7f ff dc d4 call 400020b4 <sparc_enable_interrupts>
4000ad68: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
4000ad6c: 81 c7 e0 08 ret
4000ad70: 81 e8 00 00 restore
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
4000ad74: 18 bf ff fa bgu 4000ad5c <_Watchdog_Remove+0x28> <== NEVER TAKEN
4000ad78: 03 10 00 7b sethi %hi(0x4001ec00), %g1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
4000ad7c: c2 06 00 00 ld [ %i0 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
4000ad80: c0 26 20 08 clr [ %i0 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
4000ad84: c4 00 40 00 ld [ %g1 ], %g2
4000ad88: 80 a0 a0 00 cmp %g2, 0
4000ad8c: 02 80 00 07 be 4000ada8 <_Watchdog_Remove+0x74>
4000ad90: 05 10 00 7b sethi %hi(0x4001ec00), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
4000ad94: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000ad98: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000ad9c: 84 00 c0 02 add %g3, %g2, %g2
4000ada0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
4000ada4: 05 10 00 7b sethi %hi(0x4001ec00), %g2
4000ada8: c4 00 a3 a4 ld [ %g2 + 0x3a4 ], %g2 ! 4001efa4 <_Watchdog_Sync_count>
4000adac: 80 a0 a0 00 cmp %g2, 0
4000adb0: 22 80 00 07 be,a 4000adcc <_Watchdog_Remove+0x98>
4000adb4: c4 06 20 04 ld [ %i0 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
4000adb8: 05 10 00 7c sethi %hi(0x4001f000), %g2
4000adbc: c6 00 a3 d8 ld [ %g2 + 0x3d8 ], %g3 ! 4001f3d8 <_Per_CPU_Information+0x8>
4000adc0: 05 10 00 7b sethi %hi(0x4001ec00), %g2
4000adc4: c6 20 a3 44 st %g3, [ %g2 + 0x344 ] ! 4001ef44 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000adc8: c4 06 20 04 ld [ %i0 + 4 ], %g2
next->previous = previous;
4000adcc: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
4000add0: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000add4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000add8: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 4001efa8 <_Watchdog_Ticks_since_boot>
4000addc: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
4000ade0: 7f ff dc b5 call 400020b4 <sparc_enable_interrupts>
4000ade4: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
4000ade8: 81 c7 e0 08 ret
4000adec: 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;
4000adf0: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %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;
4000adf4: 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;
4000adf8: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
4000adfc: 7f ff dc ae call 400020b4 <sparc_enable_interrupts>
4000ae00: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
4000ae04: 81 c7 e0 08 ret
4000ae08: 81 e8 00 00 restore
4000bfbc <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
4000bfbc: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
4000bfc0: 7f ff da 85 call 400029d4 <sparc_disable_interrupts>
4000bfc4: 01 00 00 00 nop
4000bfc8: b6 10 00 08 mov %o0, %i3
printk( "Watchdog Chain: %s %p\n", name, header );
4000bfcc: 11 10 00 7c sethi %hi(0x4001f000), %o0
4000bfd0: 94 10 00 19 mov %i1, %o2
4000bfd4: 92 10 00 18 mov %i0, %o1
4000bfd8: 7f ff e2 02 call 400047e0 <printk>
4000bfdc: 90 12 20 40 or %o0, 0x40, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000bfe0: 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 );
4000bfe4: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
4000bfe8: 80 a7 40 19 cmp %i5, %i1
4000bfec: 02 80 00 0f be 4000c028 <_Watchdog_Report_chain+0x6c>
4000bff0: 11 10 00 7c sethi %hi(0x4001f000), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
4000bff4: 92 10 00 1d mov %i5, %o1
4000bff8: 40 00 00 0f call 4000c034 <_Watchdog_Report>
4000bffc: 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 )
4000c000: 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 ) ;
4000c004: 80 a7 40 19 cmp %i5, %i1
4000c008: 12 bf ff fc bne 4000bff8 <_Watchdog_Report_chain+0x3c> <== NEVER TAKEN
4000c00c: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
4000c010: 11 10 00 7c sethi %hi(0x4001f000), %o0
4000c014: 92 10 00 18 mov %i0, %o1
4000c018: 7f ff e1 f2 call 400047e0 <printk>
4000c01c: 90 12 20 58 or %o0, 0x58, %o0
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
4000c020: 7f ff da 71 call 400029e4 <sparc_enable_interrupts>
4000c024: 91 e8 00 1b restore %g0, %i3, %o0
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
4000c028: 7f ff e1 ee call 400047e0 <printk>
4000c02c: 90 12 20 68 or %o0, 0x68, %o0
4000c030: 30 bf ff fc b,a 4000c020 <_Watchdog_Report_chain+0x64>
4000aeb4 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
4000aeb4: 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();
4000aeb8: 05 10 00 71 sethi %hi(0x4001c400), %g2
4000aebc: 82 10 a0 18 or %g2, 0x18, %g1 ! 4001c418 <Configuration>
4000aec0: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
4000aec4: f6 00 a0 18 ld [ %g2 + 0x18 ], %i3
4000aec8: 80 a0 e0 00 cmp %g3, 0
4000aecc: 12 80 00 03 bne 4000aed8 <_Workspace_Handler_initialization+0x24>
4000aed0: 84 10 20 00 clr %g2
4000aed4: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000aed8: b6 00 80 1b add %g2, %i3, %i3
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000aedc: c4 08 60 30 ldub [ %g1 + 0x30 ], %g2
bool unified = rtems_configuration_get_unified_work_area();
4000aee0: 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();
4000aee4: 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) {
4000aee8: 80 a6 60 00 cmp %i1, 0
4000aeec: 02 80 00 3c be 4000afdc <_Workspace_Handler_initialization+0x128><== NEVER TAKEN
4000aef0: 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;
4000aef4: 23 10 00 21 sethi %hi(0x40008400), %l1
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000aef8: 27 10 00 7b sethi %hi(0x4001ec00), %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) {
4000aefc: 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;
4000af00: a2 14 62 98 or %l1, 0x298, %l1
4000af04: a0 08 a0 ff and %g2, 0xff, %l0
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000af08: a4 08 60 ff and %g1, 0xff, %l2
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000af0c: 10 80 00 22 b 4000af94 <_Workspace_Handler_initialization+0xe0>
4000af10: a6 14 e2 d0 or %l3, 0x2d0, %l3
if ( do_zero ) {
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
4000af14: 80 a7 60 16 cmp %i5, 0x16
4000af18: 28 80 00 1c bleu,a 4000af88 <_Workspace_Handler_initialization+0xd4>
4000af1c: b8 07 20 01 inc %i4
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000af20: 80 a4 a0 00 cmp %l2, 0
4000af24: 32 80 00 0a bne,a 4000af4c <_Workspace_Handler_initialization+0x98>
4000af28: d2 06 00 00 ld [ %i0 ], %o1
size = area->size;
} else {
if ( remaining > 0 ) {
4000af2c: 80 a6 e0 00 cmp %i3, 0
4000af30: 22 80 00 22 be,a 4000afb8 <_Workspace_Handler_initialization+0x104><== NEVER TAKEN
4000af34: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
size = remaining < area->size - overhead ?
4000af38: 82 07 7f ea add %i5, -22, %g1
remaining + overhead : area->size;
4000af3c: 80 a0 40 1b cmp %g1, %i3
4000af40: 38 80 00 02 bgu,a 4000af48 <_Workspace_Handler_initialization+0x94><== ALWAYS TAKEN
4000af44: ba 06 e0 16 add %i3, 0x16, %i5
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000af48: d2 06 00 00 ld [ %i0 ], %o1
4000af4c: 94 10 00 1d mov %i5, %o2
4000af50: 90 10 00 13 mov %l3, %o0
4000af54: 9f c4 40 00 call %l1
4000af58: 96 10 20 08 mov 8, %o3
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000af5c: c2 06 00 00 ld [ %i0 ], %g1
area->size -= size;
4000af60: c4 06 20 04 ld [ %i0 + 4 ], %g2
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000af64: 82 00 40 1d add %g1, %i5, %g1
area->size -= size;
4000af68: ba 20 80 1d sub %g2, %i5, %i5
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000af6c: c2 26 00 00 st %g1, [ %i0 ]
area->size -= size;
if ( space_available < remaining ) {
4000af70: 80 a2 00 1b cmp %o0, %i3
4000af74: 1a 80 00 1f bcc 4000aff0 <_Workspace_Handler_initialization+0x13c><== ALWAYS TAKEN
4000af78: fa 26 20 04 st %i5, [ %i0 + 4 ]
remaining -= space_available;
4000af7c: b6 26 c0 08 sub %i3, %o0, %i3 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4000af80: 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) {
4000af84: b8 07 20 01 inc %i4
4000af88: 80 a7 00 19 cmp %i4, %i1
4000af8c: 02 80 00 14 be 4000afdc <_Workspace_Handler_initialization+0x128><== ALWAYS TAKEN
4000af90: b0 06 20 08 add %i0, 8, %i0
Heap_Area *area = &areas [i];
if ( do_zero ) {
4000af94: 80 a4 20 00 cmp %l0, 0
4000af98: 22 bf ff df be,a 4000af14 <_Workspace_Handler_initialization+0x60>
4000af9c: fa 06 20 04 ld [ %i0 + 4 ], %i5
memset( area->begin, 0, area->size );
4000afa0: d0 06 00 00 ld [ %i0 ], %o0
4000afa4: d4 06 20 04 ld [ %i0 + 4 ], %o2
4000afa8: 40 00 14 74 call 40010178 <memset>
4000afac: 92 10 20 00 clr %o1
}
if ( area->size > overhead ) {
4000afb0: 10 bf ff d9 b 4000af14 <_Workspace_Handler_initialization+0x60>
4000afb4: fa 06 20 04 ld [ %i0 + 4 ], %i5
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000afb8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000afbc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000afc0: 9f c4 40 00 call %l1 <== NOT EXECUTED
4000afc4: 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) {
4000afc8: b8 07 20 01 inc %i4 <== NOT EXECUTED
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
4000afcc: 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) {
4000afd0: 80 a7 00 19 cmp %i4, %i1 <== NOT EXECUTED
4000afd4: 12 bf ff f0 bne 4000af94 <_Workspace_Handler_initialization+0xe0><== NOT EXECUTED
4000afd8: b0 06 20 08 add %i0, 8, %i0 <== NOT EXECUTED
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
4000afdc: 80 a6 e0 00 cmp %i3, 0
4000afe0: 12 80 00 07 bne 4000affc <_Workspace_Handler_initialization+0x148>
4000afe4: 90 10 20 00 clr %o0
4000afe8: 81 c7 e0 08 ret
4000afec: 81 e8 00 00 restore
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
4000aff0: a2 10 00 1a mov %i2, %l1
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
4000aff4: 10 bf ff e4 b 4000af84 <_Workspace_Handler_initialization+0xd0>
4000aff8: b6 10 20 00 clr %i3
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
_Internal_error_Occurred(
4000affc: 92 10 20 01 mov 1, %o1
4000b000: 7f ff f6 43 call 4000890c <_Internal_error_Occurred>
4000b004: 94 10 20 02 mov 2, %o2
4001b4a0 <_calloc_r>:
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
4001b4a0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
4001b4a4: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4001b4a8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001b4ac: 7f ff 9e 30 call 40002d6c <calloc> <== NOT EXECUTED
4001b4b0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001b52c <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
4001b52c: 90 10 00 09 mov %o1, %o0
4001b530: 82 13 c0 00 mov %o7, %g1
4001b534: 7f ff ff e0 call 4001b4b4 <close>
4001b538: 9e 10 40 00 mov %g1, %o7
400134d8 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
400134d8: 9d e3 bf 98 save %sp, -104, %sp
400134dc: 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)
400134e0: 80 a6 e0 00 cmp %i3, 0
400134e4: 12 80 00 11 bne 40013528 <_fat_block_read+0x50> <== ALWAYS TAKEN
400134e8: b0 10 20 00 clr %i0
400134ec: 30 80 00 19 b,a 40013550 <_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));
400134f0: fa 14 00 00 lduh [ %l0 ], %i5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
400134f4: 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));
400134f8: ba 27 40 1a sub %i5, %i2, %i5
400134fc: 80 a7 40 1b cmp %i5, %i3
40013500: 08 80 00 03 bleu 4001350c <_fat_block_read+0x34>
40013504: 92 02 40 1a add %o1, %i2, %o1
40013508: ba 10 00 1b mov %i3, %i5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
4001350c: 40 00 26 46 call 4001ce24 <memcpy>
40013510: 94 10 00 1d mov %i5, %o2
count -= c;
cmpltd += c;
40013514: b0 07 40 18 add %i5, %i0, %i0
sec_num++;
40013518: 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)
4001351c: b6 a6 c0 1d subcc %i3, %i5, %i3
40013520: 02 80 00 0c be 40013550 <_fat_block_read+0x78>
40013524: b4 10 20 00 clr %i2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40013528: 92 10 00 19 mov %i1, %o1
4001352c: 94 10 20 01 mov 1, %o2
40013530: 96 07 bf fc add %fp, -4, %o3
40013534: 7f ff ff bb call 40013420 <fat_buf_access>
40013538: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
4001353c: 80 a2 20 00 cmp %o0, 0
40013540: 02 bf ff ec be 400134f0 <_fat_block_read+0x18> <== ALWAYS TAKEN
40013544: 90 07 00 18 add %i4, %i0, %o0
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
40013548: 81 c7 e0 08 ret <== NOT EXECUTED
4001354c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40013550: 81 c7 e0 08 ret
40013554: 81 e8 00 00 restore
40003d00 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40003d00: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40003d04: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40003d08: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40003d0c: 7f ff ff e9 call 40003cb0 <lstat> <== NOT EXECUTED
40003d10: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40003f38 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40003f38: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40003f3c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40003f40: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40003f44: 7f ff ff e9 call 40003ee8 <stat> <== NOT EXECUTED
40003f48: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40006ec0 <adjtime>:
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
40006ec0: 9d e3 bf 98 save %sp, -104, %sp
long adjustment;
/*
* Simple validations
*/
if ( !delta )
40006ec4: 80 a6 20 00 cmp %i0, 0
40006ec8: 02 80 00 8e be 40007100 <adjtime+0x240>
40006ecc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
40006ed0: c4 06 20 04 ld [ %i0 + 4 ], %g2
40006ed4: 03 00 03 d0 sethi %hi(0xf4000), %g1
40006ed8: 82 10 62 3f or %g1, 0x23f, %g1 ! f423f <PROM_START+0xf423f>
40006edc: 80 a0 80 01 cmp %g2, %g1
40006ee0: 18 80 00 88 bgu 40007100 <adjtime+0x240>
40006ee4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
40006ee8: 22 80 00 06 be,a 40006f00 <adjtime+0x40>
40006eec: c2 06 00 00 ld [ %i0 ], %g1
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
40006ef0: c0 26 60 04 clr [ %i1 + 4 ]
40006ef4: 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;
40006ef8: c0 26 40 00 clr [ %i1 ]
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
40006efc: c2 06 00 00 ld [ %i0 ], %g1
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
40006f00: 07 10 00 5d sethi %hi(0x40017400), %g3
40006f04: c8 00 e1 4c ld [ %g3 + 0x14c ], %g4 ! 4001754c <Configuration+0xc>
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
40006f08: bb 28 60 08 sll %g1, 8, %i5
40006f0c: 87 28 60 03 sll %g1, 3, %g3
40006f10: 86 27 40 03 sub %i5, %g3, %g3
40006f14: bb 28 e0 06 sll %g3, 6, %i5
40006f18: 86 27 40 03 sub %i5, %g3, %g3
40006f1c: 82 00 c0 01 add %g3, %g1, %g1
40006f20: 83 28 60 06 sll %g1, 6, %g1
adjustment += delta->tv_usec;
40006f24: 84 00 40 02 add %g1, %g2, %g2
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
40006f28: 80 a0 80 04 cmp %g2, %g4
40006f2c: 1a 80 00 05 bcc 40006f40 <adjtime+0x80>
40006f30: 03 10 00 65 sethi %hi(0x40019400), %g1
return 0;
40006f34: 82 10 20 00 clr %g1
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
40006f38: 81 c7 e0 08 ret
40006f3c: 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;
40006f40: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2
++level;
40006f44: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40006f48: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40006f4c: 13 10 00 65 sethi %hi(0x40019400), %o1
40006f50: 90 07 bf f8 add %fp, -8, %o0
40006f54: 40 00 07 1c call 40008bc4 <_TOD_Get_with_nanoseconds>
40006f58: 92 12 63 28 or %o1, 0x328, %o1
40006f5c: 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);
40006f60: 94 10 20 00 clr %o2
40006f64: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006f68: 90 10 00 1c mov %i4, %o0
40006f6c: 96 12 e2 00 or %o3, 0x200, %o3
40006f70: 40 00 3a 42 call 40015878 <__divdi3>
40006f74: 92 10 00 1d mov %i5, %o1
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
40006f78: f6 06 00 00 ld [ %i0 ], %i3
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006f7c: 94 10 20 00 clr %o2
40006f80: b6 06 c0 09 add %i3, %o1, %i3
40006f84: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006f88: 90 10 00 1c mov %i4, %o0
40006f8c: 96 12 e2 00 or %o3, 0x200, %o3
40006f90: 40 00 3b 25 call 40015c24 <__moddi3>
40006f94: 92 10 00 1d mov %i5, %o1
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
40006f98: 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;
40006f9c: 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;
40006fa0: 87 28 60 07 sll %g1, 7, %g3
40006fa4: 85 28 60 02 sll %g1, 2, %g2
40006fa8: 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;
40006fac: 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;
40006fb0: 82 00 80 01 add %g2, %g1, %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
40006fb4: 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;
40006fb8: 83 28 60 03 sll %g1, 3, %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
40006fbc: 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;
40006fc0: 92 02 40 01 add %o1, %g1, %o1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
40006fc4: 80 a2 40 03 cmp %o1, %g3
40006fc8: 08 80 00 07 bleu 40006fe4 <adjtime+0x124>
40006fcc: 84 06 e0 01 add %i3, 1, %g2
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
40006fd0: 92 02 40 04 add %o1, %g4, %o1
ts.tv_sec++;
40006fd4: 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 ) {
40006fd8: 80 a2 40 03 cmp %o1, %g3
40006fdc: 18 bf ff fd bgu 40006fd0 <adjtime+0x110> <== NEVER TAKEN
40006fe0: 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;
40006fe4: 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) ) {
40006fe8: 07 31 19 4d sethi %hi(0xc4653400), %g3
40006fec: 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 *));
40006ff0: 84 06 ff ff add %i3, -1, %g2
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
40006ff4: 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) ) {
40006ff8: 86 10 e2 00 or %g3, 0x200, %g3
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
40006ffc: 82 00 40 1d add %g1, %i5, %g1
ts.tv_sec--;
40007000: 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) ) {
40007004: 80 a0 40 03 cmp %g1, %g3
40007008: 08 bf ff fd bleu 40006ffc <adjtime+0x13c>
4000700c: 84 00 bf ff add %g2, -1, %g2
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40007010: 85 39 20 1f sra %g4, 0x1f, %g2
40007014: a6 10 00 01 mov %g1, %l3
40007018: a5 38 60 1f sra %g1, 0x1f, %l2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
4000701c: 83 28 a0 03 sll %g2, 3, %g1
40007020: 86 10 00 04 mov %g4, %g3
40007024: 89 31 20 1d srl %g4, 0x1d, %g4
40007028: bb 28 e0 03 sll %g3, 3, %i5
4000702c: b8 11 00 01 or %g4, %g1, %i4
40007030: 83 37 60 1b srl %i5, 0x1b, %g1
40007034: a9 2f 20 05 sll %i4, 5, %l4
40007038: ab 2f 60 05 sll %i5, 5, %l5
4000703c: a8 10 40 14 or %g1, %l4, %l4
40007040: ba a5 40 1d subcc %l5, %i5, %i5
40007044: 83 37 60 1a srl %i5, 0x1a, %g1
40007048: b8 65 00 1c subx %l4, %i4, %i4
4000704c: a3 2f 60 06 sll %i5, 6, %l1
40007050: a1 2f 20 06 sll %i4, 6, %l0
40007054: ba a4 40 1d subcc %l1, %i5, %i5
40007058: a0 10 40 10 or %g1, %l0, %l0
4000705c: b8 64 00 1c subx %l0, %i4, %i4
40007060: ae 87 40 03 addcc %i5, %g3, %l7
40007064: 83 35 e0 1e srl %l7, 0x1e, %g1
40007068: ac 47 00 02 addx %i4, %g2, %l6
4000706c: 97 2d e0 02 sll %l7, 2, %o3
40007070: 95 2d a0 02 sll %l6, 2, %o2
40007074: 86 85 c0 0b addcc %l7, %o3, %g3
40007078: 94 10 40 0a or %g1, %o2, %o2
4000707c: 9b 28 e0 02 sll %g3, 2, %o5
40007080: 84 45 80 0a addx %l6, %o2, %g2
40007084: 83 30 e0 1e srl %g3, 0x1e, %g1
40007088: ba 80 c0 0d addcc %g3, %o5, %i5
4000708c: 99 28 a0 02 sll %g2, 2, %o4
40007090: b7 2f 60 02 sll %i5, 2, %i3
40007094: 98 10 40 0c or %g1, %o4, %o4
40007098: 83 37 60 1e srl %i5, 0x1e, %g1
4000709c: b8 40 80 0c addx %g2, %o4, %i4
400070a0: 86 87 40 1b addcc %i5, %i3, %g3
400070a4: b5 2f 20 02 sll %i4, 2, %i2
400070a8: bb 30 e0 17 srl %g3, 0x17, %i5
400070ac: b4 10 40 1a or %g1, %i2, %i2
400070b0: 84 47 00 1a addx %i4, %i2, %g2
400070b4: 83 28 e0 09 sll %g3, 9, %g1
400070b8: 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 );
400070bc: 90 07 bf f8 add %fp, -8, %o0
400070c0: 84 17 40 04 or %i5, %g4, %g2
400070c4: ba 84 c0 01 addcc %l3, %g1, %i5
400070c8: b8 44 80 02 addx %l2, %g2, %i4
400070cc: 40 00 06 d9 call 40008c30 <_TOD_Set_with_timestamp>
400070d0: f8 3f bf f8 std %i4, [ %fp + -8 ]
ts.tv_sec--;
}
_TOD_Set( &ts );
_Thread_Enable_dispatch();
400070d4: 40 00 0d 7e call 4000a6cc <_Thread_Enable_dispatch>
400070d8: 01 00 00 00 nop
/* set the user's output */
if ( olddelta )
400070dc: 80 a6 60 00 cmp %i1, 0
400070e0: 02 bf ff 95 be 40006f34 <adjtime+0x74>
400070e4: 82 10 20 00 clr %g1
*olddelta = *delta;
400070e8: c4 06 00 00 ld [ %i0 ], %g2
400070ec: c4 26 40 00 st %g2, [ %i1 ]
400070f0: c4 06 20 04 ld [ %i0 + 4 ], %g2
400070f4: c4 26 60 04 st %g2, [ %i1 + 4 ]
return 0;
}
400070f8: 81 c7 e0 08 ret
400070fc: 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 );
40007100: 40 00 23 b0 call 4000ffc0 <__errno>
40007104: 01 00 00 00 nop
40007108: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
4000710c: 82 10 3f ff mov -1, %g1
40007110: 10 bf ff 8a b 40006f38 <adjtime+0x78>
40007114: c4 22 00 00 st %g2, [ %o0 ]
400070cc <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
400070cc: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
400070d0: 3b 10 00 63 sethi %hi(0x40018c00), %i5
400070d4: 40 00 04 85 call 400082e8 <pthread_mutex_lock>
400070d8: 90 17 63 f4 or %i5, 0x3f4, %o0 ! 40018ff4 <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
400070dc: 90 10 00 18 mov %i0, %o0
400070e0: 40 00 1b af call 4000df9c <fcntl>
400070e4: 92 10 20 01 mov 1, %o1
400070e8: 80 a2 20 00 cmp %o0, 0
400070ec: 06 80 00 6c bl 4000729c <aio_cancel+0x1d0>
400070f0: 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) {
400070f4: 02 80 00 3b be 400071e0 <aio_cancel+0x114>
400070f8: 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) {
400070fc: f8 06 40 00 ld [ %i1 ], %i4
40007100: 80 a7 00 18 cmp %i4, %i0
40007104: 12 80 00 2f bne 400071c0 <aio_cancel+0xf4>
40007108: 90 17 63 f4 or %i5, 0x3f4, %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);
4000710c: 92 10 00 1c mov %i4, %o1
40007110: 11 10 00 64 sethi %hi(0x40019000), %o0
40007114: 94 10 20 00 clr %o2
40007118: 40 00 01 92 call 40007760 <rtems_aio_search_fd>
4000711c: 90 12 20 3c or %o0, 0x3c, %o0
if (r_chain == NULL) {
40007120: b6 92 20 00 orcc %o0, 0, %i3
40007124: 22 80 00 0f be,a 40007160 <aio_cancel+0x94>
40007128: b6 17 63 f4 or %i5, 0x3f4, %i3
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
4000712c: b8 06 e0 1c add %i3, 0x1c, %i4
40007130: 40 00 04 6e call 400082e8 <pthread_mutex_lock>
40007134: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40007138: 92 10 00 19 mov %i1, %o1
4000713c: 40 00 01 d2 call 40007884 <rtems_aio_remove_req>
40007140: 90 06 e0 08 add %i3, 8, %o0
40007144: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
40007148: 40 00 04 88 call 40008368 <pthread_mutex_unlock>
4000714c: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007150: 40 00 04 86 call 40008368 <pthread_mutex_unlock>
40007154: 90 17 63 f4 or %i5, 0x3f4, %o0
return result;
}
return AIO_ALLDONE;
}
40007158: 81 c7 e0 08 ret
4000715c: 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)) {
40007160: c4 06 e0 54 ld [ %i3 + 0x54 ], %g2
40007164: 82 06 e0 58 add %i3, 0x58, %g1
40007168: 80 a0 80 01 cmp %g2, %g1
4000716c: 02 80 00 0f be 400071a8 <aio_cancel+0xdc> <== NEVER TAKEN
40007170: 90 06 e0 54 add %i3, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40007174: 92 10 00 1c mov %i4, %o1
40007178: 40 00 01 7a call 40007760 <rtems_aio_search_fd>
4000717c: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40007180: 80 a2 20 00 cmp %o0, 0
40007184: 02 80 00 0e be 400071bc <aio_cancel+0xf0>
40007188: 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);
4000718c: 40 00 01 be call 40007884 <rtems_aio_remove_req>
40007190: 90 02 20 08 add %o0, 8, %o0
40007194: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
40007198: 40 00 04 74 call 40008368 <pthread_mutex_unlock>
4000719c: 90 10 00 1b mov %i3, %o0
return result;
400071a0: 81 c7 e0 08 ret
400071a4: 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;
400071a8: 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);
400071ac: 40 00 04 6f call 40008368 <pthread_mutex_unlock>
400071b0: 90 17 63 f4 or %i5, 0x3f4, %o0
return AIO_ALLDONE;
400071b4: 81 c7 e0 08 ret
400071b8: 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);
400071bc: 90 10 00 1b mov %i3, %o0
400071c0: 40 00 04 6a call 40008368 <pthread_mutex_unlock>
400071c4: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one (EINVAL);
400071c8: 40 00 29 9e call 40011840 <__errno>
400071cc: 01 00 00 00 nop
400071d0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
400071d4: c2 22 00 00 st %g1, [ %o0 ]
400071d8: 81 c7 e0 08 ret
400071dc: 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);
400071e0: 11 10 00 64 sethi %hi(0x40019000), %o0
400071e4: 94 10 20 00 clr %o2
400071e8: 40 00 01 5e call 40007760 <rtems_aio_search_fd>
400071ec: 90 12 20 3c or %o0, 0x3c, %o0
if (r_chain == NULL) {
400071f0: b8 92 20 00 orcc %o0, 0, %i4
400071f4: 02 80 00 0f be 40007230 <aio_cancel+0x164>
400071f8: b6 07 20 1c add %i4, 0x1c, %i3
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
400071fc: 40 00 04 3b call 400082e8 <pthread_mutex_lock>
40007200: 90 10 00 1b mov %i3, %o0
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40007204: 40 00 0b 28 call 40009ea4 <_Chain_Extract>
40007208: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
4000720c: 40 00 01 8a call 40007834 <rtems_aio_remove_fd>
40007210: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
40007214: 40 00 04 55 call 40008368 <pthread_mutex_unlock>
40007218: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
4000721c: 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);
40007220: 40 00 04 52 call 40008368 <pthread_mutex_unlock>
40007224: 90 17 63 f4 or %i5, 0x3f4, %o0
return AIO_CANCELED;
40007228: 81 c7 e0 08 ret
4000722c: 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;
40007230: b8 17 63 f4 or %i5, 0x3f4, %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)) {
40007234: c4 07 20 54 ld [ %i4 + 0x54 ], %g2
40007238: 82 07 20 58 add %i4, 0x58, %g1
4000723c: 80 a0 80 01 cmp %g2, %g1
40007240: 02 bf ff da be 400071a8 <aio_cancel+0xdc> <== NEVER TAKEN
40007244: 90 07 20 54 add %i4, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40007248: 92 10 00 18 mov %i0, %o1
4000724c: 40 00 01 45 call 40007760 <rtems_aio_search_fd>
40007250: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40007254: b6 92 20 00 orcc %o0, 0, %i3
40007258: 22 bf ff d5 be,a 400071ac <aio_cancel+0xe0>
4000725c: b0 10 20 02 mov 2, %i0
40007260: 40 00 0b 11 call 40009ea4 <_Chain_Extract>
40007264: 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);
40007268: 40 00 01 73 call 40007834 <rtems_aio_remove_fd>
4000726c: 90 10 00 1b mov %i3, %o0
pthread_mutex_destroy (&r_chain->mutex);
40007270: 40 00 03 72 call 40008038 <pthread_mutex_destroy>
40007274: 90 10 00 1d mov %i5, %o0
pthread_cond_destroy (&r_chain->mutex);
40007278: 40 00 02 94 call 40007cc8 <pthread_cond_destroy>
4000727c: 90 10 00 1d mov %i5, %o0
free (r_chain);
40007280: 7f ff f0 1f call 400032fc <free>
40007284: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
40007288: 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);
4000728c: 40 00 04 37 call 40008368 <pthread_mutex_unlock>
40007290: 90 10 00 1c mov %i4, %o0
return AIO_CANCELED;
40007294: 81 c7 e0 08 ret
40007298: 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);
4000729c: 40 00 04 33 call 40008368 <pthread_mutex_unlock>
400072a0: 90 17 63 f4 or %i5, 0x3f4, %o0
rtems_set_errno_and_return_minus_one (EBADF);
400072a4: 40 00 29 67 call 40011840 <__errno>
400072a8: b0 10 3f ff mov -1, %i0
400072ac: 82 10 20 09 mov 9, %g1
400072b0: c2 22 00 00 st %g1, [ %o0 ]
400072b4: 81 c7 e0 08 ret
400072b8: 81 e8 00 00 restore
400072c4 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
400072c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
400072c8: 03 00 00 08 sethi %hi(0x2000), %g1
400072cc: 80 a6 00 01 cmp %i0, %g1
400072d0: 12 80 00 14 bne 40007320 <aio_fsync+0x5c>
400072d4: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
400072d8: d0 06 40 00 ld [ %i1 ], %o0
400072dc: 40 00 1b 30 call 4000df9c <fcntl>
400072e0: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
400072e4: 90 0a 20 03 and %o0, 3, %o0
400072e8: 90 02 3f ff add %o0, -1, %o0
400072ec: 80 a2 20 01 cmp %o0, 1
400072f0: 18 80 00 0c bgu 40007320 <aio_fsync+0x5c>
400072f4: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
400072f8: 7f ff f1 28 call 40003798 <malloc>
400072fc: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40007300: 80 a2 20 00 cmp %o0, 0
40007304: 02 80 00 06 be 4000731c <aio_fsync+0x58> <== NEVER TAKEN
40007308: 82 10 20 03 mov 3, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
4000730c: f2 22 20 14 st %i1, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
40007310: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
40007314: 40 00 01 78 call 400078f4 <rtems_aio_enqueue>
40007318: 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);
4000731c: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40007320: 82 10 3f ff mov -1, %g1
40007324: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
40007328: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
4000732c: 40 00 29 45 call 40011840 <__errno>
40007330: b0 10 3f ff mov -1, %i0
40007334: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
40007338: 81 c7 e0 08 ret
4000733c: 81 e8 00 00 restore
40007ad8 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
40007ad8: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40007adc: d0 06 00 00 ld [ %i0 ], %o0
40007ae0: 92 10 20 03 mov 3, %o1
40007ae4: 40 00 19 2e call 4000df9c <fcntl>
40007ae8: ba 10 20 09 mov 9, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40007aec: 80 8a 20 01 btst 1, %o0
40007af0: 12 80 00 0b bne 40007b1c <aio_read+0x44>
40007af4: 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)
40007af8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40007afc: 80 a0 60 00 cmp %g1, 0
40007b00: 12 80 00 06 bne 40007b18 <aio_read+0x40>
40007b04: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
40007b08: c2 06 20 08 ld [ %i0 + 8 ], %g1
40007b0c: 80 a0 60 00 cmp %g1, 0
40007b10: 16 80 00 0a bge 40007b38 <aio_read+0x60>
40007b14: 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);
40007b18: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff>
40007b1c: fa 26 20 34 st %i5, [ %i0 + 0x34 ]
40007b20: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
40007b24: 40 00 27 47 call 40011840 <__errno>
40007b28: b0 10 3f ff mov -1, %i0
40007b2c: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
40007b30: 81 c7 e0 08 ret
40007b34: 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));
40007b38: 7f ff ef 18 call 40003798 <malloc>
40007b3c: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40007b40: 80 a2 20 00 cmp %o0, 0
40007b44: 02 80 00 06 be 40007b5c <aio_read+0x84> <== NEVER TAKEN
40007b48: 82 10 20 01 mov 1, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40007b4c: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_READ;
40007b50: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
40007b54: 7f ff ff 68 call 400078f4 <rtems_aio_enqueue>
40007b58: 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);
40007b5c: 10 bf ff ef b 40007b18 <aio_read+0x40> <== NOT EXECUTED
40007b60: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40007b6c <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
40007b6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40007b70: d0 06 00 00 ld [ %i0 ], %o0
40007b74: 40 00 19 0a call 4000df9c <fcntl>
40007b78: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40007b7c: 90 0a 20 03 and %o0, 3, %o0
40007b80: 90 02 3f ff add %o0, -1, %o0
40007b84: 80 a2 20 01 cmp %o0, 1
40007b88: 18 80 00 0a bgu 40007bb0 <aio_write+0x44>
40007b8c: 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)
40007b90: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40007b94: 80 a0 60 00 cmp %g1, 0
40007b98: 12 80 00 06 bne 40007bb0 <aio_write+0x44>
40007b9c: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
40007ba0: c2 06 20 08 ld [ %i0 + 8 ], %g1
40007ba4: 80 a0 60 00 cmp %g1, 0
40007ba8: 16 80 00 0a bge 40007bd0 <aio_write+0x64>
40007bac: 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);
40007bb0: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff>
40007bb4: fa 26 20 34 st %i5, [ %i0 + 0x34 ]
40007bb8: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
40007bbc: 40 00 27 21 call 40011840 <__errno>
40007bc0: b0 10 3f ff mov -1, %i0
40007bc4: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
40007bc8: 81 c7 e0 08 ret
40007bcc: 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));
40007bd0: 7f ff ee f2 call 40003798 <malloc>
40007bd4: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40007bd8: 80 a2 20 00 cmp %o0, 0
40007bdc: 02 80 00 06 be 40007bf4 <aio_write+0x88> <== NEVER TAKEN
40007be0: 82 10 20 02 mov 2, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40007be4: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
40007be8: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
40007bec: 7f ff ff 42 call 400078f4 <rtems_aio_enqueue>
40007bf0: 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);
40007bf4: 10 bf ff ef b 40007bb0 <aio_write+0x44> <== NOT EXECUTED
40007bf8: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
4000812c <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)) {
4000812c: 80 a2 ff f8 cmp %o3, -8
40008130: 02 80 00 23 be 400081bc <check_and_merge+0x90>
40008134: 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);
40008138: c2 02 c0 00 ld [ %o3 ], %g1
4000813c: 80 a0 60 00 cmp %g1, 0
40008140: 22 80 00 1c be,a 400081b0 <check_and_merge+0x84>
40008144: c4 02 e0 04 ld [ %o3 + 4 ], %g2
if (b->begin < a->begin) {
40008148: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3
4000814c: c4 02 a0 18 ld [ %o2 + 0x18 ], %g2
40008150: 80 a0 c0 02 cmp %g3, %g2
40008154: 3a 80 00 07 bcc,a 40008170 <check_and_merge+0x44>
40008158: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4
4000815c: 84 10 00 0a mov %o2, %g2
40008160: c2 02 80 00 ld [ %o2 ], %g1
40008164: 94 10 00 0b mov %o3, %o2
40008168: 96 10 00 02 mov %g2, %o3
a = b;
b = t;
}
a->size += b->size;
4000816c: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4
40008170: c6 02 e0 1c ld [ %o3 + 0x1c ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40008174: c4 02 e0 04 ld [ %o3 + 4 ], %g2
40008178: 86 01 00 03 add %g4, %g3, %g3
4000817c: c6 22 a0 1c st %g3, [ %o2 + 0x1c ]
next->previous = previous;
previous->next = next;
40008180: c2 20 80 00 st %g1, [ %g2 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
40008184: c4 20 60 04 st %g2, [ %g1 + 4 ]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40008188: c2 02 00 00 ld [ %o0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000818c: d0 22 e0 04 st %o0, [ %o3 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
40008190: d6 22 00 00 st %o3, [ %o0 ]
the_node->next = before_node;
40008194: 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);
40008198: 90 10 00 09 mov %o1, %o0
before_node->previous = the_node;
4000819c: d6 20 60 04 st %o3, [ %g1 + 4 ]
400081a0: 92 02 e0 08 add %o3, 8, %o1
400081a4: 82 13 c0 00 mov %o7, %g1
400081a8: 40 00 07 13 call 40009df4 <_RBTree_Extract_unprotected>
400081ac: 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);
400081b0: 80 a0 a0 00 cmp %g2, 0
400081b4: 32 bf ff e6 bne,a 4000814c <check_and_merge+0x20> <== NEVER TAKEN
400081b8: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3 <== NOT EXECUTED
400081bc: 81 c3 e0 08 retl
4000392c <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
4000392c: 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(
40003930: 94 10 20 19 mov 0x19, %o2
40003934: 92 10 00 18 mov %i0, %o1
40003938: 90 07 bf c8 add %fp, -56, %o0
4000393c: 17 10 00 54 sethi %hi(0x40015000), %o3
40003940: 96 12 e2 64 or %o3, 0x264, %o3 ! 40015264 <rtems_global_user_env+0x4>
40003944: 40 00 04 f3 call 40004d10 <rtems_filesystem_eval_path_start_with_root_and_current>
40003948: 98 02 ff fc add %o3, -4, %o4
4000394c: 92 07 bf e0 add %fp, -32, %o1
40003950: 40 00 06 0b call 4000517c <rtems_filesystem_location_copy_and_detach>
40003954: 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 );
40003958: 40 00 06 98 call 400053b8 <rtems_filesystem_location_transform_to_global>
4000395c: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
40003960: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40003964: 39 10 00 51 sethi %hi(0x40014400), %i4
40003968: b8 17 23 14 or %i4, 0x314, %i4 ! 40014714 <rtems_filesystem_null_handlers>
4000396c: 80 a0 40 1c cmp %g1, %i4
40003970: 02 80 00 16 be 400039c8 <chroot+0x9c>
40003974: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
40003978: 40 00 06 56 call 400052d0 <rtems_filesystem_global_location_obtain>
4000397c: 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)(
40003980: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40003984: 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 =
40003988: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
4000398c: 9f c0 40 00 call %g1
40003990: 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 ) {
40003994: 80 a2 20 00 cmp %o0, 0
40003998: 02 80 00 13 be 400039e4 <chroot+0xb8>
4000399c: 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 ) ) {
400039a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400039a4: 80 a0 40 1c cmp %g1, %i4
400039a8: 02 80 00 06 be 400039c0 <chroot+0x94> <== NEVER TAKEN
400039ac: 01 00 00 00 nop
errno = eno;
400039b0: 40 00 21 ac call 4000c060 <__errno>
400039b4: 01 00 00 00 nop
400039b8: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
400039bc: 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 );
400039c0: 40 00 06 24 call 40005250 <rtems_filesystem_global_location_release>
400039c4: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
400039c8: 40 00 05 1c call 40004e38 <rtems_filesystem_eval_path_cleanup>
400039cc: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
400039d0: d0 07 bf ac ld [ %fp + -84 ], %o0
400039d4: 40 00 06 1f call 40005250 <rtems_filesystem_global_location_release>
400039d8: b0 10 3f ff mov -1, %i0
}
return rv;
}
400039dc: 81 c7 e0 08 ret
400039e0: 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();
400039e4: 40 00 03 11 call 40004628 <rtems_libio_set_private_env>
400039e8: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
400039ec: 80 a2 20 00 cmp %o0, 0
400039f0: 02 80 00 09 be 40003a14 <chroot+0xe8>
400039f4: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
400039f8: 02 bf ff f2 be 400039c0 <chroot+0x94> <== NEVER TAKEN
400039fc: 01 00 00 00 nop
errno = ENOMEM;
40003a00: 40 00 21 98 call 4000c060 <__errno>
40003a04: 01 00 00 00 nop
40003a08: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
40003a0c: 10 bf ff ed b 400039c0 <chroot+0x94>
40003a10: 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(
40003a14: 39 10 00 54 sethi %hi(0x40015000), %i4
40003a18: d0 07 22 5c ld [ %i4 + 0x25c ], %o0 ! 4001525c <rtems_current_user_env>
40003a1c: 92 10 00 1d mov %i5, %o1
40003a20: 40 00 06 22 call 400052a8 <rtems_filesystem_global_location_assign>
40003a24: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
40003a28: d2 07 bf ac ld [ %fp + -84 ], %o1
40003a2c: d0 07 22 5c ld [ %i4 + 0x25c ], %o0
40003a30: 40 00 06 1e call 400052a8 <rtems_filesystem_global_location_assign>
40003a34: b0 10 20 00 clr %i0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40003a38: 40 00 05 00 call 40004e38 <rtems_filesystem_eval_path_cleanup>
40003a3c: 90 07 bf c8 add %fp, -56, %o0
40003a40: 81 c7 e0 08 ret
40003a44: 81 e8 00 00 restore
40006d2c <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40006d2c: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40006d30: 80 a6 60 00 cmp %i1, 0
40006d34: 02 80 00 0a be 40006d5c <clock_gettime+0x30>
40006d38: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40006d3c: 02 80 00 19 be 40006da0 <clock_gettime+0x74>
40006d40: 80 a6 20 04 cmp %i0, 4
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
40006d44: 02 80 00 12 be 40006d8c <clock_gettime+0x60> <== NEVER TAKEN
40006d48: 80 a6 20 02 cmp %i0, 2
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40006d4c: 02 80 00 10 be 40006d8c <clock_gettime+0x60>
40006d50: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
40006d54: 02 80 00 08 be 40006d74 <clock_gettime+0x48>
40006d58: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40006d5c: 40 00 25 fa call 40010544 <__errno>
40006d60: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
40006d64: 82 10 20 16 mov 0x16, %g1
40006d68: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
40006d6c: 81 c7 e0 08 ret
40006d70: 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 );
40006d74: 40 00 25 f4 call 40010544 <__errno>
40006d78: b0 10 3f ff mov -1, %i0
40006d7c: 82 10 20 58 mov 0x58, %g1
40006d80: c2 22 00 00 st %g1, [ %o0 ]
40006d84: 81 c7 e0 08 ret
40006d88: 81 e8 00 00 restore
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
_TOD_Get_uptime_as_timespec( tp );
40006d8c: 90 10 00 19 mov %i1, %o0
40006d90: 40 00 08 a4 call 40009020 <_TOD_Get_uptime_as_timespec>
40006d94: b0 10 20 00 clr %i0
return 0;
40006d98: 81 c7 e0 08 ret
40006d9c: 81 e8 00 00 restore
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40006da0: 90 07 bf f8 add %fp, -8, %o0
40006da4: 13 10 00 68 sethi %hi(0x4001a000), %o1
40006da8: 40 00 08 8d call 40008fdc <_TOD_Get_with_nanoseconds>
40006dac: 92 12 63 48 or %o1, 0x348, %o1 ! 4001a348 <_TOD>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
40006db0: 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);
40006db4: 94 10 20 00 clr %o2
40006db8: 90 10 00 1c mov %i4, %o0
40006dbc: 92 10 00 1d mov %i5, %o1
40006dc0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006dc4: 40 00 3e 50 call 40016704 <__divdi3>
40006dc8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006dcc: 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);
40006dd0: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40006dd4: 90 10 00 1c mov %i4, %o0
40006dd8: 92 10 00 1d mov %i5, %o1
40006ddc: 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;
40006de0: b0 10 20 00 clr %i0
40006de4: 40 00 3f 33 call 40016ab0 <__moddi3>
40006de8: 96 12 e2 00 or %o3, 0x200, %o3
40006dec: d2 26 60 04 st %o1, [ %i1 + 4 ]
40006df0: 81 c7 e0 08 ret
40006df4: 81 e8 00 00 restore
40028884 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
40028884: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40028888: 80 a6 60 00 cmp %i1, 0
4002888c: 02 80 00 08 be 400288ac <clock_settime+0x28> <== NEVER TAKEN
40028890: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40028894: 02 80 00 0c be 400288c4 <clock_settime+0x40>
40028898: 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 )
4002889c: 02 80 00 49 be 400289c0 <clock_settime+0x13c>
400288a0: 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 )
400288a4: 02 80 00 47 be 400289c0 <clock_settime+0x13c>
400288a8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
400288ac: 40 00 4b 2f call 4003b568 <__errno>
400288b0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
400288b4: 82 10 20 16 mov 0x16, %g1
400288b8: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
400288bc: 81 c7 e0 08 ret
400288c0: 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 )
400288c4: c4 06 40 00 ld [ %i1 ], %g2
400288c8: 03 08 76 b9 sethi %hi(0x21dae400), %g1
400288cc: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff <RAM_SIZE+0x219ae4ff>
400288d0: 80 a0 80 01 cmp %g2, %g1
400288d4: 08 bf ff f6 bleu 400288ac <clock_settime+0x28>
400288d8: 03 10 01 a1 sethi %hi(0x40068400), %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;
400288dc: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 400684a0 <_Thread_Dispatch_disable_level>
++level;
400288e0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400288e4: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ]
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
400288e8: c6 06 40 00 ld [ %i1 ], %g3
400288ec: e2 06 60 04 ld [ %i1 + 4 ], %l1
400288f0: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
400288f4: 83 28 a0 03 sll %g2, 3, %g1
400288f8: bb 28 e0 03 sll %g3, 3, %i5
400288fc: 89 30 e0 1d srl %g3, 0x1d, %g4
40028900: b8 11 00 01 or %g4, %g1, %i4
40028904: 83 37 60 1b srl %i5, 0x1b, %g1
40028908: a5 2f 20 05 sll %i4, 5, %l2
4002890c: a7 2f 60 05 sll %i5, 5, %l3
40028910: a4 10 40 12 or %g1, %l2, %l2
40028914: ba a4 c0 1d subcc %l3, %i5, %i5
40028918: 83 37 60 1a srl %i5, 0x1a, %g1
4002891c: b8 64 80 1c subx %l2, %i4, %i4
40028920: 97 2f 60 06 sll %i5, 6, %o3
40028924: 95 2f 20 06 sll %i4, 6, %o2
40028928: ba a2 c0 1d subcc %o3, %i5, %i5
4002892c: 94 10 40 0a or %g1, %o2, %o2
40028930: b8 62 80 1c subx %o2, %i4, %i4
40028934: aa 87 40 03 addcc %i5, %g3, %l5
40028938: 83 35 60 1e srl %l5, 0x1e, %g1
4002893c: a8 47 00 02 addx %i4, %g2, %l4
40028940: 9b 2d 60 02 sll %l5, 2, %o5
40028944: 99 2d 20 02 sll %l4, 2, %o4
40028948: 86 85 40 0d addcc %l5, %o5, %g3
4002894c: 98 10 40 0c or %g1, %o4, %o4
40028950: b3 28 e0 02 sll %g3, 2, %i1
40028954: 84 45 00 0c addx %l4, %o4, %g2
40028958: 83 30 e0 1e srl %g3, 0x1e, %g1
4002895c: ba 80 c0 19 addcc %g3, %i1, %i5
40028960: b1 28 a0 02 sll %g2, 2, %i0
40028964: b7 2f 60 02 sll %i5, 2, %i3
40028968: b0 10 40 18 or %g1, %i0, %i0
4002896c: 83 37 60 1e srl %i5, 0x1e, %g1
40028970: b8 40 80 18 addx %g2, %i0, %i4
40028974: 86 87 40 1b addcc %i5, %i3, %g3
40028978: b5 2f 20 02 sll %i4, 2, %i2
4002897c: bb 30 e0 17 srl %g3, 0x17, %i5
40028980: b4 10 40 1a or %g1, %i2, %i2
40028984: 84 47 00 1a addx %i4, %i2, %g2
40028988: 83 28 e0 09 sll %g3, 9, %g1
4002898c: 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 );
40028990: 90 07 bf f8 add %fp, -8, %o0
40028994: 84 17 40 04 or %i5, %g4, %g2
40028998: ba 84 40 01 addcc %l1, %g1, %i5
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
4002899c: 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;
400289a0: b0 10 20 00 clr %i0
400289a4: 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 );
400289a8: 40 00 04 92 call 40029bf0 <_TOD_Set_with_timestamp>
400289ac: 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();
400289b0: 7f ff 83 a7 call 4000984c <_Thread_Enable_dispatch>
400289b4: 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;
400289b8: 81 c7 e0 08 ret
400289bc: 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 );
400289c0: 40 00 4a ea call 4003b568 <__errno>
400289c4: b0 10 3f ff mov -1, %i0
400289c8: 82 10 20 58 mov 0x58, %g1
400289cc: c2 22 00 00 st %g1, [ %o0 ]
400289d0: 81 c7 e0 08 ret
400289d4: 81 e8 00 00 restore
40002f68 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
40002f68: 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) {
40002f6c: 25 10 00 6b sethi %hi(0x4001ac00), %l2
40002f70: fa 04 a2 18 ld [ %l2 + 0x218 ], %i5 ! 4001ae18 <disktab_size>
40002f74: 80 a6 00 1d cmp %i0, %i5
40002f78: 1a 80 00 30 bcc 40003038 <create_disk+0xd0>
40002f7c: a2 10 00 18 mov %i0, %l1
40002f80: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40002f84: e0 00 62 1c ld [ %g1 + 0x21c ], %l0 ! 4001ae1c <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) {
40002f88: 83 2c 60 03 sll %l1, 3, %g1
40002f8c: fa 04 00 01 ld [ %l0 + %g1 ], %i5
40002f90: a0 04 00 01 add %l0, %g1, %l0
40002f94: 80 a7 60 00 cmp %i5, 0
40002f98: 02 80 00 0f be 40002fd4 <create_disk+0x6c>
40002f9c: f0 04 20 04 ld [ %l0 + 4 ], %i0
40002fa0: 80 a6 40 18 cmp %i1, %i0
40002fa4: 1a 80 00 0d bcc 40002fd8 <create_disk+0x70>
40002fa8: 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;
40002fac: 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) {
40002fb0: a0 87 40 01 addcc %i5, %g1, %l0
40002fb4: 02 80 00 1f be 40003030 <create_disk+0xc8> <== NEVER TAKEN
40002fb8: 01 00 00 00 nop
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
40002fbc: c2 07 40 01 ld [ %i5 + %g1 ], %g1
40002fc0: 80 a0 60 00 cmp %g1, 0
40002fc4: 02 80 00 36 be 4000309c <create_disk+0x134>
40002fc8: b0 10 20 0c mov 0xc, %i0
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
40002fcc: 81 c7 e0 08 ret
40002fd0: 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) {
40002fd4: 80 a6 20 00 cmp %i0, 0
40002fd8: 12 80 00 2b bne 40003084 <create_disk+0x11c>
40002fdc: a4 10 20 08 mov 8, %l2
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
40002fe0: 80 a6 40 12 cmp %i1, %l2
40002fe4: 3a 80 00 02 bcc,a 40002fec <create_disk+0x84>
40002fe8: a4 06 60 01 add %i1, 1, %l2
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
40002fec: 90 10 00 1d mov %i5, %o0
40002ff0: 40 00 08 12 call 40005038 <realloc>
40002ff4: 93 2c a0 02 sll %l2, 2, %o1
if (table == NULL) {
40002ff8: ba 92 20 00 orcc %o0, 0, %i5
40002ffc: 02 80 00 0d be 40003030 <create_disk+0xc8>
40003000: 94 24 80 18 sub %l2, %i0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40003004: 91 2e 20 02 sll %i0, 2, %o0
40003008: 92 10 20 00 clr %o1
4000300c: 90 07 40 08 add %i5, %o0, %o0
40003010: 40 00 45 f5 call 400147e4 <memset>
40003014: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
40003018: fa 24 00 00 st %i5, [ %l0 ]
disktab [major].size = new_size;
4000301c: e4 24 20 04 st %l2, [ %l0 + 4 ]
}
return disktab [major].minor + minor;
40003020: 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) {
40003024: a0 87 40 01 addcc %i5, %g1, %l0
40003028: 32 bf ff e6 bne,a 40002fc0 <create_disk+0x58> <== ALWAYS TAKEN
4000302c: c2 07 40 01 ld [ %i5 + %g1 ], %g1
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
return RTEMS_NO_MEMORY;
40003030: 81 c7 e0 08 ret
40003034: 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;
40003038: 27 10 00 6b sethi %hi(0x4001ac00), %l3
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
4000303c: b1 2f 60 01 sll %i5, 1, %i0
if (major >= new_size) {
40003040: 80 a4 40 18 cmp %l1, %i0
40003044: 0a 80 00 03 bcs 40003050 <create_disk+0xe8> <== NEVER TAKEN
40003048: d0 04 e2 1c ld [ %l3 + 0x21c ], %o0
new_size = major + 1;
4000304c: b0 04 60 01 add %l1, 1, %i0
}
table = realloc(table, new_size * sizeof(*table));
40003050: 40 00 07 fa call 40005038 <realloc>
40003054: 93 2e 20 03 sll %i0, 3, %o1
if (table == NULL) {
40003058: a0 92 20 00 orcc %o0, 0, %l0
4000305c: 02 bf ff f5 be 40003030 <create_disk+0xc8> <== ALWAYS TAKEN
40003060: 94 26 00 1d sub %i0, %i5, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40003064: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
40003068: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000306c: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
40003070: 40 00 45 dd call 400147e4 <memset> <== NOT EXECUTED
40003074: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
40003078: e0 24 e2 1c st %l0, [ %l3 + 0x21c ] <== NOT EXECUTED
disktab_size = new_size;
4000307c: 10 bf ff c3 b 40002f88 <create_disk+0x20> <== NOT EXECUTED
40003080: f0 24 a2 18 st %i0, [ %l2 + 0x218 ] <== NOT EXECUTED
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
40003084: a5 2e 20 01 sll %i0, 1, %l2
}
if (minor >= new_size) {
40003088: 80 a6 40 12 cmp %i1, %l2
4000308c: 0a bf ff d9 bcs 40002ff0 <create_disk+0x88> <== ALWAYS TAKEN
40003090: 90 10 00 1d mov %i5, %o0
40003094: 10 bf ff d7 b 40002ff0 <create_disk+0x88> <== NOT EXECUTED
40003098: a4 06 60 01 add %i1, 1, %l2 <== NOT EXECUTED
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
4000309c: 40 00 05 35 call 40004570 <malloc>
400030a0: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
400030a4: ba 92 20 00 orcc %o0, 0, %i5
400030a8: 02 bf ff e2 be 40003030 <create_disk+0xc8> <== NEVER TAKEN
400030ac: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
400030b0: 02 80 00 0f be 400030ec <create_disk+0x184>
400030b4: b0 10 20 00 clr %i0
alloc_name = strdup(name);
400030b8: 40 00 46 83 call 40014ac4 <strdup>
400030bc: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
400030c0: b0 92 20 00 orcc %o0, 0, %i0
400030c4: 02 80 00 16 be 4000311c <create_disk+0x1b4> <== NEVER TAKEN
400030c8: b4 10 00 08 mov %o0, %i2
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
400030cc: 94 10 00 11 mov %l1, %o2
400030d0: 13 00 00 18 sethi %hi(0x6000), %o1
400030d4: 96 10 00 19 mov %i1, %o3
400030d8: 40 00 05 95 call 4000472c <mknod>
400030dc: 92 12 61 ff or %o1, 0x1ff, %o1
400030e0: 80 a2 20 00 cmp %o0, 0
400030e4: 06 80 00 07 bl 40003100 <create_disk+0x198> <== NEVER TAKEN
400030e8: 01 00 00 00 nop
free(dd);
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
400030ec: fa 24 00 00 st %i5, [ %l0 ]
*dd_ptr = dd;
400030f0: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
400030f4: f0 27 00 00 st %i0, [ %i4 ]
return RTEMS_SUCCESSFUL;
400030f8: 81 c7 e0 08 ret
400030fc: 91 e8 20 00 restore %g0, 0, %o0
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
40003100: 40 00 03 d4 call 40004050 <free> <== NOT EXECUTED
40003104: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
40003108: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000310c: 40 00 03 d1 call 40004050 <free> <== NOT EXECUTED
40003110: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
40003114: 81 c7 e0 08 ret <== NOT EXECUTED
40003118: 81 e8 00 00 restore <== NOT EXECUTED
if (name != NULL) {
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
4000311c: 40 00 03 cd call 40004050 <free> <== NOT EXECUTED
40003120: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40003124: 30 bf ff c3 b,a 40003030 <create_disk+0xc8> <== NOT EXECUTED
40004540 <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)
40004540: 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)
40004544: 90 10 20 01 mov 1, %o0
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
40004548: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
4000454c: 40 00 03 54 call 4000529c <calloc>
40004550: 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)
40004554: 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)
40004558: ba 10 00 08 mov %o0, %i5
4000455c: 80 a2 20 00 cmp %o0, 0
40004560: 02 80 00 40 be 40004660 <data_to_part_desc.part.1+0x120> <== NEVER TAKEN
40004564: 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));
40004568: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
4000456c: da 08 60 08 ldub [ %g1 + 8 ], %o5
40004570: de 08 60 09 ldub [ %g1 + 9 ], %o7
40004574: 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));
40004578: f6 08 60 0d ldub [ %g1 + 0xd ], %i3
4000457c: f8 08 60 0e ldub [ %g1 + 0xe ], %i4
40004580: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
40004584: 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));
40004588: c6 2f bf ff stb %g3, [ %fp + -1 ]
4000458c: da 2f bf fc stb %o5, [ %fp + -4 ]
40004590: de 2f bf fd stb %o7, [ %fp + -3 ]
40004594: f0 2f bf fe stb %i0, [ %fp + -2 ]
part_desc->start = LE_TO_CPU_U32(temp);
40004598: 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);
4000459c: 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);
400045a0: 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));
400045a4: f6 2f bf fd stb %i3, [ %fp + -3 ]
400045a8: f8 2f bf fe stb %i4, [ %fp + -2 ]
400045ac: c8 2f bf ff stb %g4, [ %fp + -1 ]
400045b0: f4 2f bf fc stb %i2, [ %fp + -4 ]
part_desc->size = LE_TO_CPU_U32(temp);
400045b4: 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;
400045b8: b7 28 a0 18 sll %g2, 0x18, %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
400045bc: 89 30 a0 18 srl %g2, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400045c0: b9 30 a0 08 srl %g2, 8, %i4
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400045c4: 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;
400045c8: b8 0f 20 ff and %i4, 0xff, %i4
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400045cc: b9 2f 20 10 sll %i4, 0x10, %i4
400045d0: 88 11 00 1c or %g4, %i4, %g4
400045d4: b7 28 60 18 sll %g1, 0x18, %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
400045d8: b9 30 60 18 srl %g1, 0x18, %i4
byte3 = (value >> 16) & 0xff;
400045dc: 85 30 a0 10 srl %g2, 0x10, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400045e0: b8 16 c0 1c or %i3, %i4, %i4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400045e4: 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);
400045e8: c6 2a 00 00 stb %g3, [ %o0 ]
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400045ec: 85 28 a0 08 sll %g2, 8, %g2
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
400045f0: d2 2a 20 01 stb %o1, [ %o0 + 1 ]
400045f4: 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;
400045f8: 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);
400045fc: c4 22 20 04 st %g2, [ %o0 + 4 ]
40004600: 88 09 20 ff and %g4, 0xff, %g4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40004604: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40004608: 89 29 20 10 sll %g4, 0x10, %g4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4000460c: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40004610: b8 17 00 04 or %i4, %g4, %i4
40004614: 83 28 60 08 sll %g1, 8, %g1
40004618: 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) ||
4000461c: 82 0a 60 7f and %o1, 0x7f, %g1
40004620: 80 a0 60 05 cmp %g1, 5
40004624: 02 80 00 11 be 40004668 <data_to_part_desc.part.1+0x128>
40004628: 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)));
4000462c: 92 0a 60 ff and %o1, 0xff, %o1
40004630: 11 10 00 95 sethi %hi(0x40025400), %o0
40004634: 94 10 20 06 mov 6, %o2
40004638: 40 00 45 58 call 40015b98 <memchr>
4000463c: 90 12 22 78 or %o0, 0x278, %o0
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
40004640: 80 a2 20 00 cmp %o0, 0
40004644: 02 80 00 04 be 40004654 <data_to_part_desc.part.1+0x114>
40004648: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
4000464c: 32 80 00 08 bne,a 4000466c <data_to_part_desc.part.1+0x12c><== ALWAYS TAKEN
40004650: fa 26 40 00 st %i5, [ %i1 ]
*new_part_desc = part_desc;
}
else {
/* empty partition */
free(part_desc);
40004654: 90 10 00 1d mov %i5, %o0
40004658: 40 00 03 48 call 40005378 <free>
4000465c: b0 10 20 00 clr %i0
}
return RTEMS_SUCCESSFUL;
}
40004660: 81 c7 e0 08 ret
40004664: 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;
40004668: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
}
return RTEMS_SUCCESSFUL;
4000466c: 81 c7 e0 08 ret
40004670: 91 e8 20 00 restore %g0, 0, %o0
40002460 <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
40002460: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
40002464: 03 10 00 4d sethi %hi(0x40013400), %g1
40002468: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 ! 40013448 <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
4000246c: 05 10 00 4a sethi %hi(0x40012800), %g2
40002470: c2 00 60 04 ld [ %g1 + 4 ], %g1
40002474: 84 10 a0 7c or %g2, 0x7c, %g2
40002478: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
4000247c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40002480: 80 a0 c0 02 cmp %g3, %g2
40002484: 22 80 00 04 be,a 40002494 <devFS_Show+0x34> <== ALWAYS TAKEN
40002488: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000248c: 81 c7 e0 08 ret <== NOT EXECUTED
40002490: 81 e8 00 00 restore <== NOT EXECUTED
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
40002494: f0 00 60 04 ld [ %g1 + 4 ], %i0
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
40002498: 80 a6 20 00 cmp %i0, 0
4000249c: 02 bf ff fc be 4000248c <devFS_Show+0x2c> <== NEVER TAKEN
400024a0: f8 00 40 00 ld [ %g1 ], %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
400024a4: 23 10 00 4a sethi %hi(0x40012800), %l1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
400024a8: 35 10 00 4a sethi %hi(0x40012800), %i2
}
printk(
400024ac: 21 10 00 4a sethi %hi(0x40012800), %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) {
400024b0: b2 10 20 00 clr %i1
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
400024b4: a2 14 60 d0 or %l1, 0xd0, %l1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
400024b8: b4 16 a0 e8 or %i2, 0xe8, %i2
}
printk(
400024bc: a0 14 20 d8 or %l0, 0xd8, %l0
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
devFS_node *current = nodes + i;
if (current->name != NULL) {
400024c0: c2 07 00 00 ld [ %i4 ], %g1
400024c4: 80 a0 60 00 cmp %g1, 0
400024c8: 22 80 00 15 be,a 4000251c <devFS_Show+0xbc>
400024cc: b2 06 60 01 inc %i1
size_t j = 0;
size_t m = current->namelen;
400024d0: f6 07 20 04 ld [ %i4 + 4 ], %i3
printk("/");
400024d4: 40 00 03 e8 call 40003474 <printk>
400024d8: 90 10 00 11 mov %l1, %o0
for (j = 0; j < m; ++j) {
400024dc: 80 a6 e0 00 cmp %i3, 0
400024e0: 02 80 00 0a be 40002508 <devFS_Show+0xa8> <== NEVER TAKEN
400024e4: ba 10 20 00 clr %i5
printk("%c", current->name [j]);
400024e8: c2 07 00 00 ld [ %i4 ], %g1
400024ec: 90 10 00 1a mov %i2, %o0
400024f0: d2 48 40 1d ldsb [ %g1 + %i5 ], %o1
400024f4: 40 00 03 e0 call 40003474 <printk>
400024f8: 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) {
400024fc: 80 a7 40 1b cmp %i5, %i3
40002500: 32 bf ff fb bne,a 400024ec <devFS_Show+0x8c>
40002504: c2 07 00 00 ld [ %i4 ], %g1
printk("%c", current->name [j]);
}
printk(
40002508: d2 07 20 08 ld [ %i4 + 8 ], %o1
4000250c: d4 07 20 0c ld [ %i4 + 0xc ], %o2
40002510: 40 00 03 d9 call 40003474 <printk>
40002514: 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) {
40002518: b2 06 60 01 inc %i1
4000251c: 80 a6 40 18 cmp %i1, %i0
40002520: 12 bf ff e8 bne 400024c0 <devFS_Show+0x60>
40002524: b8 07 20 14 add %i4, 0x14, %i4
40002528: 81 c7 e0 08 ret
4000252c: 81 e8 00 00 restore
4000c5e8 <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
4000c5e8: 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;
4000c5ec: 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;
4000c5f0: e2 06 00 00 ld [ %i0 ], %l1
4000c5f4: 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;
4000c5f8: 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;
4000c5fc: 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) {
4000c600: 80 a4 20 00 cmp %l0, 0
4000c604: 02 80 00 3d be 4000c6f8 <devFS_eval_path+0x110>
4000c608: 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;
4000c60c: b4 10 20 00 clr %i2
devFS_node *free_node = NULL;
4000c610: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000c614: 10 80 00 09 b 4000c638 <devFS_eval_path+0x50>
4000c618: b8 10 20 00 clr %i4
4000c61c: 80 a6 a0 00 cmp %i2, 0
4000c620: 12 80 00 18 bne 4000c680 <devFS_eval_path+0x98> <== NEVER TAKEN
4000c624: b8 07 20 01 inc %i4
4000c628: ba 07 60 14 add %i5, 0x14, %i5
4000c62c: 80 a7 00 10 cmp %i4, %l0
4000c630: 02 80 00 1f be 4000c6ac <devFS_eval_path+0xc4>
4000c634: 82 10 00 1b mov %i3, %g1
devFS_node *current = nodes + i;
if (current->name != NULL) {
4000c638: d0 07 40 00 ld [ %i5 ], %o0
4000c63c: 80 a2 20 00 cmp %o0, 0
4000c640: 02 bf ff f7 be 4000c61c <devFS_eval_path+0x34>
4000c644: b6 10 00 1d mov %i5, %i3
if (
4000c648: c4 07 60 04 ld [ %i5 + 4 ], %g2
4000c64c: 80 a6 40 02 cmp %i1, %g2
4000c650: 12 bf ff f3 bne 4000c61c <devFS_eval_path+0x34>
4000c654: b6 10 00 01 mov %g1, %i3
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
4000c658: 92 10 00 11 mov %l1, %o1
4000c65c: 40 00 0b f2 call 4000f624 <memcmp>
4000c660: 94 10 00 19 mov %i1, %o2
4000c664: 80 a2 20 00 cmp %o0, 0
4000c668: 12 bf ff ee bne 4000c620 <devFS_eval_path+0x38>
4000c66c: 80 a6 a0 00 cmp %i2, 0
4000c670: 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) {
4000c674: 80 a6 a0 00 cmp %i2, 0
4000c678: 02 bf ff ec be 4000c628 <devFS_eval_path+0x40> <== NEVER TAKEN
4000c67c: b8 07 20 01 inc %i4
4000c680: 80 a6 e0 00 cmp %i3, 0
4000c684: 22 bf ff ea be,a 4000c62c <devFS_eval_path+0x44> <== NEVER TAKEN
4000c688: 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;
4000c68c: 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) {
4000c690: 80 88 60 40 btst 0x40, %g1
4000c694: 12 80 00 15 bne 4000c6e8 <devFS_eval_path+0x100>
4000c698: 01 00 00 00 nop
currentloc->node_access = node;
4000c69c: 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;
4000c6a0: c0 26 20 04 clr [ %i0 + 4 ]
4000c6a4: 81 c7 e0 08 ret
4000c6a8: 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) {
4000c6ac: 80 a6 a0 00 cmp %i2, 0
4000c6b0: 12 bf ff f8 bne 4000c690 <devFS_eval_path+0xa8> <== NEVER TAKEN
4000c6b4: 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) {
4000c6b8: 80 88 60 20 btst 0x20, %g1
4000c6bc: 02 80 00 0d be 4000c6f0 <devFS_eval_path+0x108> <== NEVER TAKEN
4000c6c0: 80 a6 e0 00 cmp %i3, 0
if (free_node != NULL) {
4000c6c4: 02 80 00 11 be 4000c708 <devFS_eval_path+0x120> <== NEVER TAKEN
4000c6c8: 82 10 21 ff mov 0x1ff, %g1
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
4000c6cc: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
currentloc->node_access = free_node;
4000c6d0: f6 26 20 20 st %i3, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
4000c6d4: e2 26 20 08 st %l1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
4000c6d8: 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;
4000c6dc: c0 26 20 04 clr [ %i0 + 4 ]
4000c6e0: 81 c7 e0 08 ret
4000c6e4: 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);
4000c6e8: 7f ff e2 a1 call 4000516c <rtems_filesystem_eval_path_error>
4000c6ec: 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);
4000c6f0: 7f ff e2 9f call 4000516c <rtems_filesystem_eval_path_error><== NOT EXECUTED
4000c6f4: 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) {
4000c6f8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000c6fc: 80 88 60 20 btst 0x20, %g1
4000c700: 02 bf ff fc be 4000c6f0 <devFS_eval_path+0x108> <== NEVER TAKEN
4000c704: 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);
4000c708: 7f ff e2 99 call 4000516c <rtems_filesystem_eval_path_error>
4000c70c: 93 e8 20 1c restore %g0, 0x1c, %o1
40003ee8 <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40003ee8: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
40003eec: 80 a6 a0 03 cmp %i2, 3
40003ef0: 22 80 00 18 be,a 40003f50 <devFS_mknod+0x68>
40003ef4: c2 4e 40 00 ldsb [ %i1 ], %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
40003ef8: 05 00 00 2c sethi %hi(0xb000), %g2
40003efc: 03 00 00 08 sethi %hi(0x2000), %g1
40003f00: 84 0e c0 02 and %i3, %g2, %g2
40003f04: 80 a0 80 01 cmp %g2, %g1
40003f08: 12 80 00 23 bne 40003f94 <devFS_mknod+0xac>
40003f0c: 01 00 00 00 nop
char *dupname = malloc(namelen);
40003f10: 40 00 01 5a call 40004478 <malloc>
40003f14: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
40003f18: 84 92 20 00 orcc %o0, 0, %g2
40003f1c: 02 80 00 24 be 40003fac <devFS_mknod+0xc4>
40003f20: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
40003f24: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
40003f28: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
40003f2c: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
40003f30: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
40003f34: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
40003f38: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
40003f3c: 94 10 00 1a mov %i2, %o2
40003f40: 40 00 2d e3 call 4000f6cc <memcpy>
40003f44: b0 10 20 00 clr %i0
40003f48: 81 c7 e0 08 ret
40003f4c: 81 e8 00 00 restore
dev_t dev
)
{
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
40003f50: 80 a0 60 64 cmp %g1, 0x64
40003f54: 12 bf ff ea bne 40003efc <devFS_mknod+0x14> <== NEVER TAKEN
40003f58: 05 00 00 2c sethi %hi(0xb000), %g2
40003f5c: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
40003f60: 80 a0 60 65 cmp %g1, 0x65
40003f64: 12 bf ff e7 bne 40003f00 <devFS_mknod+0x18> <== NEVER TAKEN
40003f68: 03 00 00 08 sethi %hi(0x2000), %g1
40003f6c: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
40003f70: 80 a0 60 76 cmp %g1, 0x76
40003f74: 12 bf ff e3 bne 40003f00 <devFS_mknod+0x18> <== NEVER TAKEN
40003f78: 03 00 00 08 sethi %hi(0x2000), %g1
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
40003f7c: 03 00 00 3c sethi %hi(0xf000), %g1
40003f80: b6 0e c0 01 and %i3, %g1, %i3
40003f84: 03 00 00 10 sethi %hi(0x4000), %g1
40003f88: 80 a6 c0 01 cmp %i3, %g1
40003f8c: 02 bf ff ef be 40003f48 <devFS_mknod+0x60> <== ALWAYS TAKEN
40003f90: b0 10 20 00 clr %i0
errno = ENOTSUP;
40003f94: 40 00 2b 35 call 4000ec68 <__errno>
40003f98: b0 10 3f ff mov -1, %i0
40003f9c: 82 10 20 86 mov 0x86, %g1
40003fa0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
}
return rv;
}
40003fa4: 81 c7 e0 08 ret
40003fa8: 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;
40003fac: 40 00 2b 2f call 4000ec68 <__errno>
40003fb0: b0 10 3f ff mov -1, %i0
40003fb4: 82 10 20 0c mov 0xc, %g1
40003fb8: c2 22 00 00 st %g1, [ %o0 ]
40003fbc: 81 c7 e0 08 ret
40003fc0: 81 e8 00 00 restore
40002ef0 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
40002ef0: 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);
40002ef4: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40002ef8: d0 00 62 14 ld [ %g1 + 0x214 ], %o0 ! 4001ae14 <diskdevs_mutex>
40002efc: 92 10 20 00 clr %o1
40002f00: 94 10 20 00 clr %o2
40002f04: 40 00 15 d1 call 40008648 <rtems_semaphore_obtain>
40002f08: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
40002f0c: 80 a2 20 00 cmp %o0, 0
40002f10: 12 80 00 05 bne 40002f24 <disk_lock+0x34> <== NEVER TAKEN
40002f14: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
40002f18: 03 10 00 6b sethi %hi(0x4001ac00), %g1
return RTEMS_SUCCESSFUL;
40002f1c: 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;
40002f20: c4 28 62 10 stb %g2, [ %g1 + 0x210 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
40002f24: 81 c7 e0 08 ret
40002f28: 81 e8 00 00 restore
40002f2c <disk_unlock>:
static void
disk_unlock(void)
{
40002f2c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
40002f30: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40002f34: d0 00 62 14 ld [ %g1 + 0x214 ], %o0 ! 4001ae14 <diskdevs_mutex>
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
40002f38: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40002f3c: c0 28 62 10 clrb [ %g1 + 0x210 ] ! 4001ae10 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
40002f40: 40 00 16 11 call 40008784 <rtems_semaphore_release>
40002f44: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40002f48: 80 a2 20 00 cmp %o0, 0
40002f4c: 12 80 00 04 bne 40002f5c <disk_unlock+0x30> <== NEVER TAKEN
40002f50: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
40002f54: 81 c7 e0 08 ret
40002f58: 81 e8 00 00 restore
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
40002f5c: 40 00 17 75 call 40008d30 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002f60: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40004bc8 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
40004bc8: 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);
40004bcc: 7f ff f5 36 call 400020a4 <sparc_disable_interrupts>
40004bd0: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
40004bd4: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
40004bd8: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40004bdc: 80 a0 80 01 cmp %g2, %g1
40004be0: 02 80 00 14 be 40004c30 <drainOutput.part.0+0x68> <== ALWAYS TAKEN
40004be4: 01 00 00 00 nop
tty->rawOutBufState = rob_wait;
40004be8: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2> <== NOT EXECUTED
40004bec: f8 26 20 94 st %i4, [ %i0 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable (level);
40004bf0: 7f ff f5 31 call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40004bf4: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
40004bf8: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
40004bfc: 92 10 20 00 clr %o1 <== NOT EXECUTED
40004c00: 40 00 09 e3 call 4000738c <rtems_semaphore_obtain> <== NOT EXECUTED
40004c04: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40004c08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004c0c: 12 80 00 0b bne 40004c38 <drainOutput.part.0+0x70> <== NOT EXECUTED
40004c10: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
40004c14: 7f ff f5 24 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
40004c18: 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) {
40004c1c: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED
40004c20: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40004c24: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40004c28: 32 bf ff f2 bne,a 40004bf0 <drainOutput.part.0+0x28> <== NOT EXECUTED
40004c2c: 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);
40004c30: 7f ff f5 21 call 400020b4 <sparc_enable_interrupts>
40004c34: 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);
40004c38: 40 00 0b ba call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40003594 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
40003594: 92 10 20 00 clr %o1
40003598: 94 10 20 00 clr %o2
4000359c: 82 13 c0 00 mov %o7, %g1
400035a0: 40 00 00 0c call 400035d0 <fcntl>
400035a4: 9e 10 40 00 mov %g1, %o7
400035a8: 40 00 37 10 call 400111e8 <_fwalk_reent+0x14> <== NOT EXECUTED
400035ac: 40 00 37 04 call 400111bc <_fwalk+0x70> <== NOT EXECUTED
400035b0: 40 00 36 e4 call 40011140 <fseek+0x18> <== NOT EXECUTED
400035b4: 40 00 36 c4 call 400110c4 <_fseek_r+0x53c> <== NOT EXECUTED
400035b8: 40 00 36 70 call 40010f78 <_fseek_r+0x3f0> <== NOT EXECUTED
400035bc: 40 00 36 58 call 40010f1c <_fseek_r+0x394> <== NOT EXECUTED
400035c0: 40 00 36 58 call 40010f20 <_fseek_r+0x398> <== NOT EXECUTED
400035c4: 40 00 36 58 call 40010f24 <_fseek_r+0x39c> <== NOT EXECUTED
400035c8: 40 00 36 58 call 40010f28 <_fseek_r+0x3a0> <== NOT EXECUTED
400035cc: 40 00 36 58 call 40010f2c <_fseek_r+0x3a4> <== NOT EXECUTED
40003548 <dup2>:
*/
int dup2(
int fildes,
int fildes2
)
{
40003548: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
4000354c: 90 10 00 18 mov %i0, %o0
40003550: 40 00 01 50 call 40003a90 <fstat>
40003554: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
40003558: 80 a2 3f ff cmp %o0, -1
4000355c: 02 80 00 0c be 4000358c <dup2+0x44>
40003560: 90 10 00 19 mov %i1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
40003564: 40 00 01 4b call 40003a90 <fstat>
40003568: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
4000356c: 80 a2 3f ff cmp %o0, -1
40003570: 02 80 00 07 be 4000358c <dup2+0x44> <== NEVER TAKEN
40003574: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
40003578: 92 10 20 00 clr %o1
4000357c: 40 00 00 15 call 400035d0 <fcntl>
40003580: 94 10 00 19 mov %i1, %o2
}
40003584: 81 c7 e0 08 ret
40003588: 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;
4000358c: 81 c7 e0 08 ret
40003590: 91 e8 3f ff restore %g0, -1, %o0
400059ec <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
400059ec: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
400059f0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
400059f4: 80 88 62 00 btst 0x200, %g1
400059f8: 02 80 00 0d be 40005a2c <echo+0x40> <== NEVER TAKEN
400059fc: 03 10 00 79 sethi %hi(0x4001e400), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
40005a00: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 4001e560 <__ctype_ptr__>
40005a04: 82 00 40 18 add %g1, %i0, %g1
40005a08: 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) &&
40005a0c: 80 88 60 20 btst 0x20, %g1
40005a10: 02 80 00 08 be 40005a30 <echo+0x44>
40005a14: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
40005a18: 82 06 3f f7 add %i0, -9, %g1
40005a1c: 82 08 60 ff and %g1, 0xff, %g1
40005a20: 80 a0 60 01 cmp %g1, 1
40005a24: 18 80 00 07 bgu 40005a40 <echo+0x54>
40005a28: 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);
40005a2c: 90 10 00 18 mov %i0, %o0
40005a30: 7f ff ff 8f call 4000586c <oproc>
40005a34: 92 10 00 19 mov %i1, %o1
40005a38: 81 c7 e0 08 ret
40005a3c: 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;
40005a40: 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] = '^';
40005a44: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
40005a48: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
40005a4c: 90 07 bf f8 add %fp, -8, %o0
40005a50: 92 10 20 02 mov 2, %o1
40005a54: 7f ff ff 36 call 4000572c <rtems_termios_puts>
40005a58: 94 10 00 19 mov %i1, %o2
tty->column += 2;
40005a5c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
40005a60: 82 00 60 02 add %g1, 2, %g1
40005a64: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
40005a68: 81 c7 e0 08 ret
40005a6c: 81 e8 00 00 restore
40027728 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
40027728: 03 10 01 9f sethi %hi(0x40067c00), %g1
4002772c: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 40067ee0 <group_fp>
40027730: 80 a2 20 00 cmp %o0, 0
40027734: 02 80 00 05 be 40027748 <endgrent+0x20> <== NEVER TAKEN
40027738: 01 00 00 00 nop
fclose(group_fp);
4002773c: 82 13 c0 00 mov %o7, %g1
40027740: 40 00 4f dc call 4003b6b0 <fclose>
40027744: 9e 10 40 00 mov %g1, %o7
40027748: 81 c3 e0 08 retl <== NOT EXECUTED
4002758c <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
4002758c: 03 10 01 9f sethi %hi(0x40067c00), %g1
40027590: d0 00 62 00 ld [ %g1 + 0x200 ], %o0 ! 40067e00 <passwd_fp>
40027594: 80 a2 20 00 cmp %o0, 0
40027598: 02 80 00 05 be 400275ac <endpwent+0x20> <== NEVER TAKEN
4002759c: 01 00 00 00 nop
fclose(passwd_fp);
400275a0: 82 13 c0 00 mov %o7, %g1
400275a4: 40 00 50 43 call 4003b6b0 <fclose>
400275a8: 9e 10 40 00 mov %g1, %o7
400275ac: 81 c3 e0 08 retl <== NOT EXECUTED
40005a70 <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)
40005a70: 9d e3 bf a0 save %sp, -96, %sp
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40005a74: 37 10 00 73 sethi %hi(0x4001cc00), %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)
40005a78: ba 10 00 18 mov %i0, %i5
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
40005a7c: 35 10 00 79 sethi %hi(0x4001e400), %i2
rtems_termios_puts ("\b \b", 3, tty);
40005a80: 31 10 00 73 sethi %hi(0x4001cc00), %i0
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40005a84: b6 16 e3 58 or %i3, 0x358, %i3
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
40005a88: 10 80 00 0f b 40005ac4 <erase.part.2+0x54>
40005a8c: b0 16 23 60 or %i0, 0x360, %i0
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
40005a90: 90 12 23 60 or %o0, 0x360, %o0
40005a94: 92 10 20 03 mov 3, %o1
40005a98: 7f ff ff 25 call 4000572c <rtems_termios_puts>
40005a9c: 94 10 00 1d mov %i5, %o2
if (tty->column)
40005aa0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40005aa4: 80 a0 60 00 cmp %g1, 0
40005aa8: 02 80 00 05 be 40005abc <erase.part.2+0x4c> <== NEVER TAKEN
40005aac: 80 a6 60 00 cmp %i1, 0
tty->column--;
40005ab0: 82 00 7f ff add %g1, -1, %g1
40005ab4: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
40005ab8: 80 a6 60 00 cmp %i1, 0
40005abc: 02 80 00 58 be 40005c1c <erase.part.2+0x1ac>
40005ac0: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
40005ac4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40005ac8: 80 a0 a0 00 cmp %g2, 0
40005acc: 02 80 00 54 be 40005c1c <erase.part.2+0x1ac>
40005ad0: 84 00 bf ff add %g2, -1, %g2
unsigned char c = tty->cbuf[--tty->ccount];
40005ad4: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
if (tty->termios.c_lflag & ECHO) {
40005ad8: c6 07 60 3c ld [ %i5 + 0x3c ], %g3
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
40005adc: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
40005ae0: 80 88 e0 08 btst 8, %g3
40005ae4: 02 bf ff f5 be 40005ab8 <erase.part.2+0x48> <== NEVER TAKEN
40005ae8: c2 09 00 02 ldub [ %g4 + %g2 ], %g1
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
40005aec: 80 a6 60 00 cmp %i1, 0
40005af0: 12 80 00 05 bne 40005b04 <erase.part.2+0x94>
40005af4: 82 08 60 ff and %g1, 0xff, %g1
40005af8: 80 88 e0 10 btst 0x10, %g3
40005afc: 22 80 00 4d be,a 40005c30 <erase.part.2+0x1c0> <== NEVER TAKEN
40005b00: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
40005b04: 80 a0 60 09 cmp %g1, 9
40005b08: 02 80 00 1e be 40005b80 <erase.part.2+0x110>
40005b0c: 80 a0 a0 00 cmp %g2, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
40005b10: c4 06 a1 60 ld [ %i2 + 0x160 ], %g2
40005b14: b8 00 60 01 add %g1, 1, %i4
40005b18: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
40005b1c: 80 88 60 20 btst 0x20, %g1
40005b20: 02 bf ff dc be 40005a90 <erase.part.2+0x20> <== ALWAYS TAKEN
40005b24: 11 10 00 73 sethi %hi(0x4001cc00), %o0
40005b28: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED
40005b2c: 02 bf ff e4 be 40005abc <erase.part.2+0x4c> <== NOT EXECUTED
40005b30: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
40005b34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005b38: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
40005b3c: 7f ff fe fc call 4000572c <rtems_termios_puts> <== NOT EXECUTED
40005b40: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
40005b44: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
40005b48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005b4c: 12 80 00 3b bne 40005c38 <erase.part.2+0x1c8> <== NOT EXECUTED
40005b50: 11 10 00 73 sethi %hi(0x4001cc00), %o0 <== NOT EXECUTED
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
40005b54: c2 06 a1 60 ld [ %i2 + 0x160 ], %g1 <== NOT EXECUTED
40005b58: c2 08 40 1c ldub [ %g1 + %i4 ], %g1 <== NOT EXECUTED
40005b5c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40005b60: 22 bf ff cd be,a 40005a94 <erase.part.2+0x24> <== NOT EXECUTED
40005b64: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
40005b68: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
40005b6c: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
40005b70: 32 bf ff c9 bne,a 40005a94 <erase.part.2+0x24> <== NOT EXECUTED
40005b74: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
40005b78: 10 bf ff d1 b 40005abc <erase.part.2+0x4c> <== NOT EXECUTED
40005b7c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40005b80: 02 80 00 17 be 40005bdc <erase.part.2+0x16c>
40005b84: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
40005b88: da 06 a1 60 ld [ %i2 + 0x160 ], %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;
40005b8c: 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)
40005b90: 10 80 00 07 b 40005bac <erase.part.2+0x13c>
40005b94: 98 08 e2 00 and %g3, 0x200, %o4
40005b98: 32 80 00 02 bne,a 40005ba0 <erase.part.2+0x130> <== NOT EXECUTED
40005b9c: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40005ba0: 80 a0 80 01 cmp %g2, %g1
40005ba4: 22 80 00 0f be,a 40005be0 <erase.part.2+0x170> <== NEVER TAKEN
40005ba8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
c = tty->cbuf[i++];
40005bac: c6 09 00 01 ldub [ %g4 + %g1 ], %g3
40005bb0: 82 00 60 01 inc %g1
if (c == '\t') {
40005bb4: 80 a0 e0 09 cmp %g3, 9
40005bb8: 02 80 00 1b be 40005c24 <erase.part.2+0x1b4>
40005bbc: 9e 03 40 03 add %o5, %g3, %o7
col = (col | 7) + 1;
} else if (iscntrl (c)) {
40005bc0: de 0b e0 01 ldub [ %o7 + 1 ], %o7
40005bc4: 80 8b e0 20 btst 0x20, %o7
40005bc8: 12 bf ff f4 bne 40005b98 <erase.part.2+0x128> <== NEVER TAKEN
40005bcc: 80 a3 20 00 cmp %o4, 0
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40005bd0: 80 a0 80 01 cmp %g2, %g1
40005bd4: 12 bf ff f6 bne 40005bac <erase.part.2+0x13c>
40005bd8: b8 07 20 01 inc %i4
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40005bdc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40005be0: 80 a0 40 1c cmp %g1, %i4
40005be4: 04 bf ff b6 ble 40005abc <erase.part.2+0x4c> <== NEVER TAKEN
40005be8: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
40005bec: 90 10 00 1b mov %i3, %o0
40005bf0: 92 10 20 01 mov 1, %o1
40005bf4: 7f ff fe ce call 4000572c <rtems_termios_puts>
40005bf8: 94 10 00 1d mov %i5, %o2
tty->column--;
40005bfc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40005c00: 82 00 7f ff add %g1, -1, %g1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40005c04: 80 a0 40 1c cmp %g1, %i4
40005c08: 14 bf ff f9 bg 40005bec <erase.part.2+0x17c>
40005c0c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
40005c10: 80 a6 60 00 cmp %i1, 0
40005c14: 32 bf ff ad bne,a 40005ac8 <erase.part.2+0x58> <== ALWAYS TAKEN
40005c18: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40005c1c: 81 c7 e0 08 ret
40005c20: 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;
40005c24: b8 17 20 07 or %i4, 7, %i4
40005c28: 10 bf ff de b 40005ba0 <erase.part.2+0x130>
40005c2c: 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);
40005c30: 7f ff ff 6f call 400059ec <echo> <== NOT EXECUTED
40005c34: 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--;
40005c38: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40005c3c: 10 bf ff c6 b 40005b54 <erase.part.2+0xe4> <== NOT EXECUTED
40005c40: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
400040fc <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
)
{
400040fc: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
40004100: 92 10 20 00 clr %o1
40004104: 90 10 00 18 mov %i0, %o0
40004108: 40 00 30 1c call 40010178 <memset>
4000410c: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
40004110: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
40004114: 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) {
40004118: 80 a6 a0 00 cmp %i2, 0
4000411c: 02 80 00 21 be 400041a0 <eval_path_start+0xa4>
40004120: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40004124: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40004128: 40 00 01 a3 call 400047b4 <rtems_filesystem_global_location_obtain>
4000412c: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
40004130: 83 2e e0 18 sll %i3, 0x18, %g1
40004134: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40004138: 80 a0 60 5c cmp %g1, 0x5c
4000413c: 12 80 00 32 bne 40004204 <eval_path_start+0x108> <== ALWAYS TAKEN
40004140: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
++ctx->path;
40004144: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
--ctx->pathlen;
40004148: 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;
4000414c: 84 00 a0 01 inc %g2
--ctx->pathlen;
40004150: 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;
40004154: c4 26 00 00 st %g2, [ %i0 ]
--ctx->pathlen;
40004158: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
4000415c: 40 00 01 96 call 400047b4 <rtems_filesystem_global_location_obtain>
40004160: 90 06 20 30 add %i0, 0x30, %o0
40004164: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40004168: 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;
4000416c: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40004170: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40004174: c2 00 40 00 ld [ %g1 ], %g1
40004178: 9f c0 40 00 call %g1
4000417c: 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(
40004180: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40004184: 40 00 1e e1 call 4000bd08 <rtems_filesystem_location_clone>
40004188: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
4000418c: 90 10 00 18 mov %i0, %o0
40004190: 7f ff ff be call 40004088 <rtems_filesystem_eval_path_continue>
40004194: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
40004198: 81 c7 e0 08 ret
4000419c: 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;
400041a0: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
400041a4: 40 00 01 84 call 400047b4 <rtems_filesystem_global_location_obtain>
400041a8: 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;
400041ac: 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();
400041b0: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
400041b4: 40 00 01 80 call 400047b4 <rtems_filesystem_global_location_obtain>
400041b8: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
400041bc: 40 00 2d 61 call 4000f740 <__errno>
400041c0: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
400041c4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
400041c8: 84 10 20 02 mov 2, %g2
400041cc: 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;
400041d0: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
400041d4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400041d8: c2 00 40 00 ld [ %g1 ], %g1
400041dc: 9f c0 40 00 call %g1
400041e0: 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(
400041e4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
400041e8: 40 00 1e c8 call 4000bd08 <rtems_filesystem_location_clone>
400041ec: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
400041f0: 90 10 00 18 mov %i0, %o0
400041f4: 7f ff ff a5 call 40004088 <rtems_filesystem_eval_path_continue>
400041f8: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
400041fc: 81 c7 e0 08 ret
40004200: 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)) {
40004204: 80 a0 60 2f cmp %g1, 0x2f
40004208: 22 bf ff d0 be,a 40004148 <eval_path_start+0x4c>
4000420c: 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(
40004210: 40 00 01 69 call 400047b4 <rtems_filesystem_global_location_obtain>
40004214: 90 10 00 1d mov %i5, %o0
40004218: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
4000421c: 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;
40004220: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40004224: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40004228: c2 00 40 00 ld [ %g1 ], %g1
4000422c: 9f c0 40 00 call %g1
40004230: 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(
40004234: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40004238: 40 00 1e b4 call 4000bd08 <rtems_filesystem_location_clone>
4000423c: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
40004240: 90 10 00 18 mov %i0, %o0
40004244: 7f ff ff 91 call 40004088 <rtems_filesystem_eval_path_continue>
40004248: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
4000424c: 81 c7 e0 08 ret
40004250: 81 e8 00 00 restore
40013420 <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)
{
40013420: 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);
40013424: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
40013428: 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)
4001342c: c6 0e 20 89 ldub [ %i0 + 0x89 ], %g3
40013430: 84 20 80 01 sub %g2, %g1, %g2
40013434: 80 a0 e0 00 cmp %g3, 0
40013438: 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);
4001343c: 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 -
40013440: 84 26 40 02 sub %i1, %g2, %g2
40013444: 02 80 00 06 be 4001345c <fat_buf_access+0x3c>
40013448: b9 28 80 01 sll %g2, %g1, %i4
4001344c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40013450: 80 a0 40 19 cmp %g1, %i1
40013454: 22 80 00 12 be,a 4001349c <fat_buf_access+0x7c>
40013458: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
{
fat_buf_release(fs_info);
4001345c: 7f ff ff 7a call 40013244 <fat_buf_release>
40013460: 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);
40013464: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
40013468: 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)
4001346c: 80 a6 a0 01 cmp %i2, 1
40013470: 02 80 00 10 be 400134b0 <fat_buf_access+0x90>
40013474: 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);
40013478: 7f ff f6 c9 call 40010f9c <rtems_bdbuf_get>
4001347c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
40013480: 80 a2 20 00 cmp %o0, 0
40013484: 12 80 00 0f bne 400134c0 <fat_buf_access+0xa0> <== NEVER TAKEN
40013488: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = sec_num;
4001348c: f2 26 20 84 st %i1, [ %i0 + 0x84 ]
fs_info->c.modified = 0;
40013490: c0 2e 20 88 clrb [ %i0 + 0x88 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
40013494: c2 2e 20 89 stb %g1, [ %i0 + 0x89 ]
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
40013498: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
4001349c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400134a0: b8 00 40 1c add %g1, %i4, %i4
400134a4: f8 26 c0 00 st %i4, [ %i3 ]
return RC_OK;
}
400134a8: 81 c7 e0 08 ret
400134ac: 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);
400134b0: 7f ff f6 fb call 4001109c <rtems_bdbuf_read>
400134b4: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
400134b8: 10 bf ff f3 b 40013484 <fat_buf_access+0x64>
400134bc: 80 a2 20 00 cmp %o0, 0
rtems_set_errno_and_return_minus_one(EIO);
400134c0: 40 00 23 b4 call 4001c390 <__errno> <== NOT EXECUTED
400134c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400134c8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400134cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400134d0: 81 c7 e0 08 ret <== NOT EXECUTED
400134d4: 81 e8 00 00 restore <== NOT EXECUTED
40013244 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
40013244: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
40013248: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
4001324c: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
40013250: 80 a0 60 00 cmp %g1, 0
40013254: 02 80 00 6b be 40013400 <fat_buf_release+0x1bc>
40013258: b0 10 20 00 clr %i0
return RC_OK;
if (fs_info->c.modified)
4001325c: c2 0f 60 88 ldub [ %i5 + 0x88 ], %g1
40013260: 80 a0 60 00 cmp %g1, 0
40013264: 02 80 00 47 be 40013380 <fat_buf_release+0x13c>
40013268: 01 00 00 00 nop
{
uint32_t sec_num = fs_info->c.blk_num;
4001326c: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
40013270: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
40013274: 80 a0 40 02 cmp %g1, %g2
40013278: 0a 80 00 06 bcs 40013290 <fat_buf_release+0x4c>
4001327c: b8 10 20 00 clr %i4
40013280: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40013284: 80 a0 40 02 cmp %g1, %g2
40013288: 2a 80 00 46 bcs,a 400133a0 <fat_buf_release+0x15c>
4001328c: 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);
40013290: 7f ff f8 40 call 40011390 <rtems_bdbuf_release_modified>
40013294: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
40013298: 80 a2 20 00 cmp %o0, 0
4001329c: 12 80 00 5b bne 40013408 <fat_buf_release+0x1c4> <== NEVER TAKEN
400132a0: 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)
400132a4: 02 80 00 3c be 40013394 <fat_buf_release+0x150>
400132a8: c0 2f 60 88 clrb [ %i5 + 0x88 ]
400132ac: c2 0f 60 54 ldub [ %i5 + 0x54 ], %g1
400132b0: 80 a0 60 00 cmp %g1, 0
400132b4: 32 80 00 39 bne,a 40013398 <fat_buf_release+0x154> <== NEVER TAKEN
400132b8: c0 2f 60 89 clrb [ %i5 + 0x89 ] <== NOT EXECUTED
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
400132bc: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
400132c0: 80 a0 60 01 cmp %g1, 1
400132c4: 08 80 00 34 bleu 40013394 <fat_buf_release+0x150> <== NEVER TAKEN
400132c8: b6 10 20 01 mov 1, %i3
400132cc: 10 80 00 16 b 40013324 <fat_buf_release+0xe0>
400132d0: 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);
400132d4: 7f ff f7 72 call 4001109c <rtems_bdbuf_read>
400132d8: 94 07 bf fc add %fp, -4, %o2
}
if ( sc != RTEMS_SUCCESSFUL)
400132dc: 80 a2 20 00 cmp %o0, 0
400132e0: 12 80 00 44 bne 400133f0 <fat_buf_release+0x1ac> <== NEVER TAKEN
400132e4: 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);
400132e8: d2 07 60 90 ld [ %i5 + 0x90 ], %o1
400132ec: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400132f0: d4 17 40 00 lduh [ %i5 ], %o2
400132f4: 40 00 26 cc call 4001ce24 <memcpy>
400132f8: 90 02 00 1c add %o0, %i4, %o0
sc = rtems_bdbuf_release_modified(bd);
400132fc: d0 07 bf fc ld [ %fp + -4 ], %o0
40013300: 7f ff f8 24 call 40011390 <rtems_bdbuf_release_modified>
40013304: b6 06 e0 01 inc %i3
if ( sc != RTEMS_SUCCESSFUL)
40013308: 80 a2 20 00 cmp %o0, 0
4001330c: 12 80 00 39 bne 400133f0 <fat_buf_release+0x1ac> <== NEVER TAKEN
40013310: 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++)
40013314: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
40013318: 80 a2 00 01 cmp %o0, %g1
4001331c: 3a 80 00 1f bcc,a 40013398 <fat_buf_release+0x154> <== ALWAYS TAKEN
40013320: c0 2f 60 89 clrb [ %i5 + 0x89 ]
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
40013324: 7f ff bc 9a call 4000258c <.umul>
40013328: 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);
4001332c: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
40013330: c6 07 60 84 ld [ %i5 + 0x84 ], %g3
40013334: c4 0f 60 0c ldub [ %i5 + 0xc ], %g2
40013338: 90 02 00 03 add %o0, %g3, %o0
4001333c: 84 20 80 01 sub %g2, %g1, %g2
40013340: 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);
40013344: 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 -
40013348: 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);
4001334c: 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
40013350: 80 a7 20 00 cmp %i4, 0
40013354: 12 bf ff e0 bne 400132d4 <fat_buf_release+0x90>
40013358: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
4001335c: c4 17 40 00 lduh [ %i5 ], %g2
40013360: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
40013364: 80 a0 80 01 cmp %g2, %g1
40013368: 12 bf ff db bne 400132d4 <fat_buf_release+0x90>
4001336c: 01 00 00 00 nop
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
40013370: 7f ff f7 0b call 40010f9c <rtems_bdbuf_get>
40013374: 94 07 bf fc add %fp, -4, %o2
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
}
if ( sc != RTEMS_SUCCESSFUL)
40013378: 10 bf ff da b 400132e0 <fat_buf_release+0x9c>
4001337c: 80 a2 20 00 cmp %o0, 0
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
40013380: 7f ff f7 cc call 400112b0 <rtems_bdbuf_release>
40013384: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
40013388: 80 a2 20 00 cmp %o0, 0
4001338c: 12 80 00 1f bne 40013408 <fat_buf_release+0x1c4> <== NEVER TAKEN
40013390: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
40013394: c0 2f 60 89 clrb [ %i5 + 0x89 ]
return RC_OK;
40013398: 81 c7 e0 08 ret
4001339c: 91 e8 20 00 restore %g0, 0, %o0
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
400133a0: c8 0f 60 02 ldub [ %i5 + 2 ], %g4
400133a4: 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)
400133a8: 80 a0 a0 00 cmp %g2, 0
400133ac: 12 bf ff b9 bne 40013290 <fat_buf_release+0x4c> <== NEVER TAKEN
400133b0: b8 10 20 01 mov 1, %i4
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
400133b4: 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,
400133b8: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
400133bc: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
400133c0: 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);
400133c4: 84 09 20 ff and %g4, 0xff, %g2
400133c8: 86 08 e0 ff and %g3, 0xff, %g3
400133cc: 86 20 c0 02 sub %g3, %g2, %g3
400133d0: 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);
400133d4: 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 -
400133d8: 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);
400133dc: 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) &&
400133e0: 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,
400133e4: 40 00 26 90 call 4001ce24 <memcpy>
400133e8: 92 02 40 02 add %o1, %g2, %o1
400133ec: 30 bf ff a9 b,a 40013290 <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);
400133f0: 40 00 23 e8 call 4001c390 <__errno> <== NOT EXECUTED
400133f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400133f8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
400133fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013400: 81 c7 e0 08 ret
40013404: 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);
40013408: 40 00 23 e2 call 4001c390 <__errno> <== NOT EXECUTED
4001340c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013410: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40013414: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013418: 81 c7 e0 08 ret <== NOT EXECUTED
4001341c: 81 e8 00 00 restore <== NOT EXECUTED
40013608 <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)
{
40013608: 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));
4001360c: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40013610: 82 20 40 1a sub %g1, %i2, %g1
40013614: 80 a6 c0 01 cmp %i3, %g1
40013618: 38 80 00 02 bgu,a 40013620 <fat_cluster_set+0x18> <== NEVER TAKEN
4001361c: 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)) )
40013620: 80 a6 60 00 cmp %i1, 0
40013624: 32 80 00 06 bne,a 4001363c <fat_cluster_set+0x34> <== ALWAYS TAKEN
40013628: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
4001362c: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1 <== NOT EXECUTED
40013630: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40013634: 12 80 00 50 bne 40013774 <fat_cluster_set+0x16c> <== NOT EXECUTED
40013638: 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);
4001363c: e0 0e 20 02 ldub [ %i0 + 2 ], %l0
40013640: 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);
40013644: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
40013648: 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;
4001364c: b2 06 7f fe add %i1, -2, %i1
40013650: a1 30 c0 10 srl %g3, %l0, %l0
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40013654: 84 20 80 01 sub %g2, %g1, %g2
40013658: b3 2e 40 02 sll %i1, %g2, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4001365c: 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;
40013660: 85 36 80 01 srl %i2, %g1, %g2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
40013664: 83 28 80 01 sll %g2, %g1, %g1
ssize_t bytes_written = 0;
40013668: 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);
4001366c: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
40013670: 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;
40013674: 82 10 20 00 clr %g1
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
40013678: 80 a6 e0 00 cmp %i3, 0
4001367c: 02 80 00 25 be 40013710 <fat_cluster_set+0x108> <== NEVER TAKEN
40013680: a4 10 20 01 mov 1, %l2
40013684: 80 a0 60 00 cmp %g1, 0
40013688: 32 80 00 39 bne,a 4001376c <fat_cluster_set+0x164> <== NEVER TAKEN
4001368c: 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));
40013690: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
40013694: 82 20 80 1a sub %g2, %i2, %g1
40013698: 80 a0 40 1b cmp %g1, %i3
4001369c: 08 80 00 03 bleu 400136a8 <fat_cluster_set+0xa0> <== ALWAYS TAKEN
400136a0: ba 10 00 01 mov %g1, %i5
400136a4: 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));
400136a8: 80 a7 40 01 cmp %i5, %g1
400136ac: 08 80 00 03 bleu 400136b8 <fat_cluster_set+0xb0> <== ALWAYS TAKEN
400136b0: b2 10 00 1d mov %i5, %i1
400136b4: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
400136b8: 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)
400136bc: 80 a6 60 00 cmp %i1, 0
400136c0: 02 80 00 24 be 40013750 <fat_cluster_set+0x148> <== NEVER TAKEN
400136c4: 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);
400136c8: 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);
400136cc: 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)
400136d0: 80 a0 80 19 cmp %g2, %i1
400136d4: 02 80 00 21 be 40013758 <fat_cluster_set+0x150>
400136d8: 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);
400136dc: 94 10 20 01 mov 1, %o2
400136e0: 7f ff ff 50 call 40013420 <fat_buf_access>
400136e4: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
400136e8: 80 a2 20 00 cmp %o0, 0
400136ec: 22 80 00 14 be,a 4001373c <fat_cluster_set+0x134> <== ALWAYS TAKEN
400136f0: d0 07 bf fc ld [ %fp + -4 ], %o0
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
400136f4: 80 a2 00 1d cmp %o0, %i5
400136f8: 02 80 00 0b be 40013724 <fat_cluster_set+0x11c> <== ALWAYS TAKEN
400136fc: 82 10 3f ff mov -1, %g1
40013700: 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)
40013704: 80 a6 e0 00 cmp %i3, 0
40013708: 12 bf ff e0 bne 40013688 <fat_cluster_set+0x80> <== NEVER TAKEN
4001370c: 80 a0 60 00 cmp %g1, 0
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
40013710: 80 a0 60 00 cmp %g1, 0
40013714: 12 80 00 16 bne 4001376c <fat_cluster_set+0x164> <== NEVER TAKEN
40013718: b0 10 3f ff mov -1, %i0
4001371c: 81 c7 e0 08 ret
40013720: 91 e8 00 11 restore %g0, %l1, %o0
pattern);
if (c != ret)
rc = -1;
else
{
bytes_to_write -= ret;
40013724: b6 26 c0 08 sub %i3, %o0, %i3
bytes_written += ret;
40013728: a2 04 40 08 add %l1, %o0, %l1
++cur_blk;
4001372c: a0 04 20 01 inc %l0
40013730: 82 10 20 00 clr %g1
40013734: 10 bf ff f4 b 40013704 <fat_cluster_set+0xfc>
40013738: 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);
4001373c: 92 10 00 1c mov %i4, %o1
40013740: 90 02 00 1a add %o0, %i2, %o0
40013744: 40 00 25 f5 call 4001cf18 <memset>
40013748: 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;
4001374c: e4 2e 20 88 stb %l2, [ %i0 + 0x88 ]
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
40013750: 10 bf ff e9 b 400136f4 <fat_cluster_set+0xec>
40013754: 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);
40013758: 94 10 20 02 mov 2, %o2
4001375c: 7f ff ff 31 call 40013420 <fat_buf_access>
40013760: 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)
40013764: 10 bf ff e2 b 400136ec <fat_cluster_set+0xe4>
40013768: 80 a2 20 00 cmp %o0, 0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4001376c: 81 c7 e0 08 ret <== NOT EXECUTED
40013770: 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);
40013774: c4 0e 20 02 ldub [ %i0 + 2 ], %g2 <== NOT EXECUTED
40013778: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED
4001377c: 84 20 40 02 sub %g1, %g2, %g2 <== NOT EXECUTED
40013780: 10 bf ff b8 b 40013660 <fat_cluster_set+0x58> <== NOT EXECUTED
40013784: a1 34 00 02 srl %l0, %g2, %l0 <== NOT EXECUTED
40013788 <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
40013788: 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));
4001378c: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40013790: 82 20 40 1a sub %g1, %i2, %g1
40013794: 80 a6 c0 01 cmp %i3, %g1
40013798: 38 80 00 02 bgu,a 400137a0 <fat_cluster_write+0x18> <== NEVER TAKEN
4001379c: 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)) )
400137a0: 80 a6 60 00 cmp %i1, 0
400137a4: 32 80 00 06 bne,a 400137bc <fat_cluster_write+0x34>
400137a8: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
400137ac: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
400137b0: 80 88 60 03 btst 3, %g1
400137b4: 12 80 00 52 bne 400138fc <fat_cluster_write+0x174> <== ALWAYS TAKEN
400137b8: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
400137bc: e2 0e 20 02 ldub [ %i0 + 2 ], %l1
400137c0: 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);
400137c4: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
400137c8: 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;
400137cc: b2 06 7f fe add %i1, -2, %i1
400137d0: a3 30 c0 11 srl %g3, %l1, %l1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400137d4: 84 20 80 01 sub %g2, %g1, %g2
400137d8: b3 2e 40 02 sll %i1, %g2, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
400137dc: 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);
400137e0: 85 36 80 01 srl %i2, %g1, %g2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400137e4: 83 28 80 01 sll %g2, %g1, %g1
ssize_t bytes_written = 0;
400137e8: 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);
400137ec: 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;
400137f0: 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;
400137f4: 82 10 20 00 clr %g1
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
400137f8: 80 a6 e0 00 cmp %i3, 0
400137fc: 02 80 00 27 be 40013898 <fat_cluster_write+0x110> <== NEVER TAKEN
40013800: a6 10 20 01 mov 1, %l3
40013804: 80 a0 60 00 cmp %g1, 0
40013808: 32 80 00 3b bne,a 400138f4 <fat_cluster_write+0x16c> <== NEVER TAKEN
4001380c: 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));
40013810: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
40013814: 82 20 80 1a sub %g2, %i2, %g1
40013818: 80 a0 40 1b cmp %g1, %i3
4001381c: 08 80 00 03 bleu 40013828 <fat_cluster_write+0xa0>
40013820: b2 10 00 01 mov %g1, %i1
40013824: 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));
40013828: 80 a6 40 01 cmp %i1, %g1
4001382c: 08 80 00 03 bleu 40013838 <fat_cluster_write+0xb0> <== ALWAYS TAKEN
40013830: a0 10 00 19 mov %i1, %l0
40013834: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
40013838: 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)
4001383c: 80 a4 20 00 cmp %l0, 0
40013840: 02 80 00 26 be 400138d8 <fat_cluster_write+0x150> <== NEVER TAKEN
40013844: 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);
40013848: 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);
4001384c: 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
40013850: 80 a7 60 00 cmp %i5, 0
40013854: 12 80 00 23 bne 400138e0 <fat_cluster_write+0x158>
40013858: 93 2c 40 09 sll %l1, %o1, %o1
|| (bytes_to_write == fs_info->vol.bytes_per_block))
4001385c: 80 a0 80 10 cmp %g2, %l0
40013860: 02 80 00 20 be 400138e0 <fat_cluster_write+0x158>
40013864: 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);
40013868: 7f ff fe ee call 40013420 <fat_buf_access>
4001386c: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
40013870: 80 a2 20 00 cmp %o0, 0
40013874: 22 80 00 14 be,a 400138c4 <fat_cluster_write+0x13c> <== ALWAYS TAKEN
40013878: d0 07 bf fc ld [ %fp + -4 ], %o0
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
4001387c: 80 a2 00 19 cmp %o0, %i1
40013880: 02 80 00 0b be 400138ac <fat_cluster_write+0x124> <== ALWAYS TAKEN
40013884: 82 10 3f ff mov -1, %g1
40013888: b4 10 20 00 clr %i2 <== NOT EXECUTED
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
4001388c: 80 a6 e0 00 cmp %i3, 0
40013890: 12 bf ff de bne 40013808 <fat_cluster_write+0x80> <== NEVER TAKEN
40013894: 80 a0 60 00 cmp %g1, 0
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
40013898: 80 a0 60 00 cmp %g1, 0
4001389c: 12 80 00 16 bne 400138f4 <fat_cluster_write+0x16c> <== NEVER TAKEN
400138a0: b0 10 3f ff mov -1, %i0
400138a4: 81 c7 e0 08 ret
400138a8: 91 e8 00 12 restore %g0, %l2, %o0
overwrite_cluster);
if (c != ret)
rc = -1;
else
{
bytes_to_write -= ret;
400138ac: b6 26 c0 08 sub %i3, %o0, %i3
bytes_written += ret;
400138b0: a4 04 80 08 add %l2, %o0, %l2
++cur_blk;
400138b4: a2 04 60 01 inc %l1
400138b8: 82 10 20 00 clr %g1
400138bc: 10 bf ff f4 b 4001388c <fat_cluster_write+0x104>
400138c0: 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);
400138c4: 92 07 00 12 add %i4, %l2, %o1
400138c8: 90 02 00 1a add %o0, %i2, %o0
400138cc: 40 00 25 56 call 4001ce24 <memcpy>
400138d0: 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;
400138d4: e6 2e 20 88 stb %l3, [ %i0 + 0x88 ]
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
400138d8: 10 bf ff e9 b 4001387c <fat_cluster_write+0xf4>
400138dc: 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);
400138e0: 94 10 20 02 mov 2, %o2
400138e4: 7f ff fe cf call 40013420 <fat_buf_access>
400138e8: 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)
400138ec: 10 bf ff e2 b 40013874 <fat_cluster_write+0xec>
400138f0: 80 a2 20 00 cmp %o0, 0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
400138f4: 81 c7 e0 08 ret <== NOT EXECUTED
400138f8: 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);
400138fc: c4 0e 20 02 ldub [ %i0 + 2 ], %g2
40013900: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
40013904: 84 20 40 02 sub %g1, %g2, %g2
40013908: 10 bf ff b6 b 400137e0 <fat_cluster_write+0x58>
4001390c: a3 34 40 02 srl %l1, %g2, %l1
40012a90 <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40012a90: 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)
40012a94: c2 06 60 08 ld [ %i1 + 8 ], %g1
40012a98: 80 a0 60 01 cmp %g1, 1
40012a9c: 08 80 00 06 bleu 40012ab4 <fat_file_close+0x24>
40012aa0: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
40012aa4: 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--;
40012aa8: c2 26 60 08 st %g1, [ %i1 + 8 ]
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
return rc;
}
40012aac: 81 c7 e0 08 ret
40012ab0: 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)
40012ab4: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
40012ab8: 80 88 60 01 btst 1, %g1
40012abc: 22 80 00 15 be,a 40012b10 <fat_file_close+0x80>
40012ac0: d2 06 60 0c ld [ %i1 + 0xc ], %o1
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
40012ac4: 90 10 00 18 mov %i0, %o0
40012ac8: 92 10 00 19 mov %i1, %o1
40012acc: 7f ff ff b0 call 4001298c <fat_file_truncate>
40012ad0: 94 10 20 00 clr %o2
if ( rc != RC_OK )
40012ad4: 80 a2 20 00 cmp %o0, 0
40012ad8: 12 bf ff f5 bne 40012aac <fat_file_close+0x1c> <== NEVER TAKEN
40012adc: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40012ae0: 40 00 0f 88 call 40016900 <_Chain_Extract>
40012ae4: 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) )
40012ae8: d2 06 60 0c ld [ %i1 + 0xc ], %o1
40012aec: 40 00 06 7a call 400144d4 <fat_ino_is_unique>
40012af0: 90 10 00 18 mov %i0, %o0
40012af4: 80 8a 20 ff btst 0xff, %o0
40012af8: 32 80 00 11 bne,a 40012b3c <fat_file_close+0xac> <== NEVER TAKEN
40012afc: 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);
40012b00: 7f ff c8 2b call 40004bac <free>
40012b04: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
40012b08: 40 00 01 cf call 40013244 <fat_buf_release>
40012b0c: 81 e8 00 00 restore
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
40012b10: 40 00 06 71 call 400144d4 <fat_ino_is_unique>
40012b14: 90 10 00 18 mov %i0, %o0
40012b18: 80 8a 20 ff btst 0xff, %o0
40012b1c: 02 80 00 05 be 40012b30 <fat_file_close+0xa0>
40012b20: 01 00 00 00 nop
{
fat_fd->links_num = 0;
40012b24: c0 26 60 08 clr [ %i1 + 8 ]
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
40012b28: 40 00 01 c7 call 40013244 <fat_buf_release>
40012b2c: 81 e8 00 00 restore
40012b30: 40 00 0f 74 call 40016900 <_Chain_Extract>
40012b34: 90 10 00 19 mov %i1, %o0
40012b38: 30 bf ff f2 b,a 40012b00 <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);
40012b3c: 40 00 06 5b call 400144a8 <fat_free_unique_ino> <== NOT EXECUTED
40012b40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012b44: 30 bf ff ef b,a 40012b00 <fat_file_close+0x70> <== NOT EXECUTED
40012c1c <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
40012c1c: 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;
40012c20: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
40012c24: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
40012c28: 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;
40012c2c: 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)
40012c30: 80 a6 c0 01 cmp %i3, %g1
40012c34: 08 80 00 16 bleu 40012c8c <fat_file_extend+0x70>
40012c38: ba 10 00 18 mov %i0, %i5
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40012c3c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40012c40: 80 a0 a0 01 cmp %g2, 1
40012c44: 22 80 00 56 be,a 40012d9c <fat_file_extend+0x180>
40012c48: 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))) &
40012c4c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
40012c50: 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))) &
40012c54: 84 04 3f ff add %l0, -1, %g2
40012c58: 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 -
40012c5c: a0 24 00 12 sub %l0, %l2, %l0
40012c60: 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)
40012c64: 80 a4 00 03 cmp %l0, %g3
40012c68: 1a 80 00 03 bcc 40012c74 <fat_file_extend+0x58>
40012c6c: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
40012c70: a2 20 c0 10 sub %g3, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
40012c74: 80 a4 20 00 cmp %l0, 0
40012c78: 12 80 00 3c bne 40012d68 <fat_file_extend+0x14c>
40012c7c: 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)
40012c80: 80 a4 60 00 cmp %l1, 0
40012c84: 32 80 00 04 bne,a 40012c94 <fat_file_extend+0x78>
40012c88: 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;
40012c8c: 81 c7 e0 08 ret
40012c90: 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;
40012c94: a4 04 7f ff add %l1, -1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40012c98: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40012c9c: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40012ca0: 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;
40012ca4: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40012ca8: 96 07 bf fc add %fp, -4, %o3
40012cac: 94 10 00 12 mov %l2, %o2
40012cb0: 98 07 bf f8 add %fp, -8, %o4
40012cb4: 40 00 1e 90 call 4001a6f4 <fat_scan_fat_for_free_clusters>
40012cb8: 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)
40012cbc: b0 92 20 00 orcc %o0, 0, %i0
40012cc0: 12 80 00 28 bne 40012d60 <fat_file_extend+0x144> <== NEVER TAKEN
40012cc4: 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))
40012cc8: 80 94 00 01 orcc %l0, %g1, %g0
40012ccc: 02 80 00 3b be 40012db8 <fat_file_extend+0x19c> <== NEVER TAKEN
40012cd0: 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)
40012cd4: 02 80 00 09 be 40012cf8 <fat_file_extend+0xdc> <== ALWAYS TAKEN
40012cd8: a4 24 80 01 sub %l2, %g1, %l2
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
40012cdc: c6 17 60 06 lduh [ %i5 + 6 ], %g3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40012ce0: 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);
40012ce4: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
40012ce8: a2 0c 40 03 and %l1, %g3, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40012cec: 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);
40012cf0: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40012cf4: 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 )
40012cf8: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
40012cfc: 80 a2 e0 00 cmp %o3, 0
40012d00: 32 80 00 43 bne,a 40012e0c <fat_file_extend+0x1f0>
40012d04: d2 06 60 3c ld [ %i1 + 0x3c ], %o1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
40012d08: c4 07 bf f0 ld [ %fp + -16 ], %g2
fat_fd->map.file_cln = 0;
40012d0c: 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;
40012d10: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
40012d14: 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)
40012d18: 80 a0 60 00 cmp %g1, 0
40012d1c: 22 80 00 39 be,a 40012e00 <fat_file_extend+0x1e4> <== NEVER TAKEN
40012d20: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
40012d24: c4 07 bf f8 ld [ %fp + -8 ], %g2
if (fat_fd->fat_file_type == FAT_DIRECTORY)
40012d28: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40012d2c: 80 a0 60 00 cmp %g1, 0
40012d30: 12 80 00 33 bne 40012dfc <fat_file_extend+0x1e0>
40012d34: c4 26 60 3c st %g2, [ %i1 + 0x3c ]
{
rc = fat_init_clusters_chain(fs_info, chain);
40012d38: d2 07 bf f0 ld [ %fp + -16 ], %o1
40012d3c: 40 00 05 80 call 4001433c <fat_init_clusters_chain>
40012d40: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40012d44: 82 92 20 00 orcc %o0, 0, %g1
40012d48: 22 80 00 2e be,a 40012e00 <fat_file_extend+0x1e4> <== ALWAYS TAKEN
40012d4c: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
40012d50: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
40012d54: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
40012d58: 40 00 1e 2f call 4001a614 <fat_free_fat_clusters_chain> <== NOT EXECUTED
40012d5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012d60: 81 c7 e0 08 ret <== NOT EXECUTED
40012d64: 81 e8 00 00 restore <== NOT EXECUTED
if (bytes2add > bytes_remain)
bytes2add -= bytes_remain;
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
40012d68: 02 bf ff c7 be 40012c84 <fat_file_extend+0x68>
40012d6c: 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;
40012d70: 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);
40012d74: 90 10 00 1d mov %i5, %o0
40012d78: 92 10 00 19 mov %i1, %o1
40012d7c: 95 30 40 0a srl %g1, %o2, %o2
40012d80: 7f ff fd 9b call 400123ec <fat_file_lseek>
40012d84: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40012d88: b0 92 60 00 orcc %o1, 0, %i0
40012d8c: 02 80 00 11 be 40012dd0 <fat_file_extend+0x1b4> <== ALWAYS TAKEN
40012d90: d2 07 bf fc ld [ %fp + -4 ], %o1
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
40012d94: 81 c7 e0 08 ret <== NOT EXECUTED
40012d98: 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)) &&
40012d9c: 80 a0 a0 00 cmp %g2, 0
40012da0: 32 bf ff ac bne,a 40012c50 <fat_file_extend+0x34> <== NEVER TAKEN
40012da4: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40012da8: 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)) &&
40012dac: 80 88 a0 03 btst 3, %g2
40012db0: 22 bf ff a8 be,a 40012c50 <fat_file_extend+0x34> <== NEVER TAKEN
40012db4: 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);
40012db8: 40 00 25 76 call 4001c390 <__errno>
40012dbc: b0 10 3f ff mov -1, %i0
40012dc0: 82 10 20 1c mov 0x1c, %g1
40012dc4: c2 22 00 00 st %g1, [ %o0 ]
40012dc8: 81 c7 e0 08 ret
40012dcc: 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);
40012dd0: 90 10 00 1d mov %i5, %o0
40012dd4: 94 10 00 12 mov %l2, %o2
40012dd8: 96 10 00 10 mov %l0, %o3
40012ddc: 98 10 20 00 clr %o4
40012de0: 40 00 02 0a call 40013608 <fat_cluster_set>
40012de4: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
40012de8: 80 a2 00 10 cmp %o0, %l0
40012dec: 02 bf ff a6 be 40012c84 <fat_file_extend+0x68> <== ALWAYS TAKEN
40012df0: 80 a4 60 00 cmp %l1, 0
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
40012df4: 81 c7 e0 08 ret <== NOT EXECUTED
40012df8: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
*a_length = new_length;
40012dfc: f6 27 00 00 st %i3, [ %i4 ]
fat_fd->fat_file_size = new_length;
40012e00: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
40012e04: 81 c7 e0 08 ret
40012e08: 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)
40012e0c: 80 a2 7f ff cmp %o1, -1
40012e10: 22 80 00 0d be,a 40012e44 <fat_file_extend+0x228> <== NEVER TAKEN
40012e14: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
40012e18: 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);
40012e1c: d4 07 bf f0 ld [ %fp + -16 ], %o2
40012e20: 40 00 1d 4b call 4001a34c <fat_set_fat_cluster>
40012e24: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40012e28: 82 92 20 00 orcc %o0, 0, %g1
40012e2c: 12 bf ff ca bne 40012d54 <fat_file_extend+0x138> <== NEVER TAKEN
40012e30: d2 07 bf f0 ld [ %fp + -16 ], %o1
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
40012e34: 40 00 01 04 call 40013244 <fat_buf_release>
40012e38: 90 10 00 1d mov %i5, %o0
40012e3c: 10 bf ff b7 b 40012d18 <fat_file_extend+0xfc>
40012e40: 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,
40012e44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012e48: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40012e4c: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
40012e50: 7f ff ff 3e call 40012b48 <fat_file_ioctl> <== NOT EXECUTED
40012e54: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
40012e58: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
40012e5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012e60: 02 bf ff ef be 40012e1c <fat_file_extend+0x200> <== NOT EXECUTED
40012e64: 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);
40012e68: 10 bf ff bb b 40012d54 <fat_file_extend+0x138> <== NOT EXECUTED
40012e6c: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
40012b48 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
40012b48: 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);
40012b4c: 82 07 a0 50 add %fp, 0x50, %g1
40012b50: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40012b54: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40012b58: 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;
40012b5c: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
40012b60: 80 a6 a0 01 cmp %i2, 1
40012b64: 02 80 00 08 be 40012b84 <fat_file_ioctl+0x3c> <== ALWAYS TAKEN
40012b68: c2 27 bf fc st %g1, [ %fp + -4 ]
*ret = cur_cln;
break;
default:
errno = EINVAL;
40012b6c: 40 00 26 09 call 4001c390 <__errno> <== NOT EXECUTED
40012b70: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012b74: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40012b78: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
break;
}
va_end(ap);
return rc;
}
40012b7c: 81 c7 e0 08 ret <== NOT EXECUTED
40012b80: 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 ) {
40012b84: 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 *);
40012b88: 86 07 a0 58 add %fp, 0x58, %g3
40012b8c: c6 27 bf fc st %g3, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
40012b90: 80 a6 c0 02 cmp %i3, %g2
40012b94: 1a 80 00 1c bcc 40012c04 <fat_file_ioctl+0xbc> <== NEVER TAKEN
40012b98: 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)) &&
40012b9c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40012ba0: 80 a0 60 01 cmp %g1, 1
40012ba4: 22 80 00 0e be,a 40012bdc <fat_file_ioctl+0x94>
40012ba8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
40012bac: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
40012bb0: 90 10 00 18 mov %i0, %o0
40012bb4: 92 10 00 19 mov %i1, %o1
40012bb8: 95 36 c0 0a srl %i3, %o2, %o2
40012bbc: 7f ff fe 0c call 400123ec <fat_file_lseek>
40012bc0: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
40012bc4: b0 92 60 00 orcc %o1, 0, %i0
40012bc8: 12 bf ff ed bne 40012b7c <fat_file_ioctl+0x34> <== NEVER TAKEN
40012bcc: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
40012bd0: c2 27 40 00 st %g1, [ %i5 ]
break;
40012bd4: 81 c7 e0 08 ret
40012bd8: 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)) &&
40012bdc: 80 a0 60 00 cmp %g1, 0
40012be0: 32 bf ff f4 bne,a 40012bb0 <fat_file_ioctl+0x68> <== NEVER TAKEN
40012be4: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40012be8: 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)) &&
40012bec: 80 88 60 03 btst 3, %g1
40012bf0: 22 bf ff f0 be,a 40012bb0 <fat_file_ioctl+0x68>
40012bf4: 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;
40012bf8: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
40012bfc: 81 c7 e0 08 ret
40012c00: 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 );
40012c04: 40 00 25 e3 call 4001c390 <__errno> <== NOT EXECUTED
40012c08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012c0c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40012c10: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012c14: 81 c7 e0 08 ret <== NOT EXECUTED
40012c18: 81 e8 00 00 restore <== NOT EXECUTED
400123ec <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
400123ec: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
400123f0: f8 06 60 34 ld [ %i1 + 0x34 ], %i4
400123f4: 80 a7 00 1a cmp %i4, %i2
400123f8: 22 80 00 26 be,a 40012490 <fat_file_lseek+0xa4>
400123fc: 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)
40012400: 2a 80 00 19 bcs,a 40012464 <fat_file_lseek+0x78>
40012404: 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;
40012408: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001240c: b8 10 00 1a mov %i2, %i4
40012410: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
40012414: 80 a7 20 00 cmp %i4, 0
40012418: 12 80 00 07 bne 40012434 <fat_file_lseek+0x48>
4001241c: ba 10 20 00 clr %i5
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
40012420: 10 80 00 14 b 40012470 <fat_file_lseek+0x84>
40012424: 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++)
40012428: 80 a7 40 1c cmp %i5, %i4
4001242c: 02 80 00 11 be 40012470 <fat_file_lseek+0x84>
40012430: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40012434: d2 07 bf fc ld [ %fp + -4 ], %o1
40012438: 90 10 00 18 mov %i0, %o0
4001243c: 40 00 1f 40 call 4001a13c <fat_get_fat_cluster>
40012440: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40012444: 80 a2 20 00 cmp %o0, 0
40012448: 22 bf ff f8 be,a 40012428 <fat_file_lseek+0x3c> <== ALWAYS TAKEN
4001244c: ba 07 60 01 inc %i5
return rc;
40012450: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
40012454: 85 3a 20 1f sra %o0, 0x1f, %g2 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
40012458: b2 10 00 03 mov %g3, %i1 <== NOT EXECUTED
4001245c: 81 c7 e0 08 ret <== NOT EXECUTED
40012460: 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;
40012464: 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;
40012468: 10 bf ff eb b 40012414 <fat_file_lseek+0x28>
4001246c: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
40012470: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
40012474: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
}
return RC_OK;
40012478: 84 10 20 00 clr %g2
4001247c: 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;
40012480: c2 26 c0 00 st %g1, [ %i3 ]
}
return RC_OK;
}
40012484: b0 10 00 02 mov %g2, %i0
40012488: 81 c7 e0 08 ret
4001248c: 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;
40012490: 84 10 20 00 clr %g2
40012494: 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;
40012498: c2 26 c0 00 st %g1, [ %i3 ]
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
4001249c: b0 10 00 02 mov %g2, %i0
400124a0: 81 c7 e0 08 ret
400124a4: 93 e8 00 03 restore %g0, %g3, %o1
400130d4 <fat_file_mark_removed>:
void
fat_file_mark_removed(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
400130d4: 9d e3 bf a0 save %sp, -96, %sp
400130d8: 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)
400130dc: 80 a0 60 01 cmp %g1, 1
400130e0: 02 80 00 26 be 40013178 <fat_file_mark_removed+0xa4> <== NEVER TAKEN
400130e4: 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)) )
400130e8: 32 80 00 1f bne,a 40013164 <fat_file_mark_removed+0x90> <== NEVER TAKEN
400130ec: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
400130f0: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
400130f4: 80 88 a0 03 btst 3, %g2
400130f8: 22 80 00 1b be,a 40013164 <fat_file_mark_removed+0x90> <== NEVER TAKEN
400130fc: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40013100: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
40013104: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
40013108: bb 2f 40 02 sll %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4001310c: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40013110: 90 10 00 19 mov %i1, %o0
40013114: 87 30 a0 09 srl %g2, 9, %g3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
40013118: 85 30 a0 05 srl %g2, 5, %g2
4001311c: 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) +
40013120: ba 07 40 03 add %i5, %g3, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
40013124: bb 2f 60 04 sll %i5, 4, %i5
40013128: 40 00 0d f6 call 40016900 <_Chain_Extract>
4001312c: 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);
40013130: d0 06 20 70 ld [ %i0 + 0x70 ], %o0
40013134: 82 0f 60 01 and %i5, 1, %g1
40013138: 85 28 60 02 sll %g1, 2, %g2
4001313c: 83 28 60 04 sll %g1, 4, %g1
40013140: 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 );
40013144: 92 10 00 19 mov %i1, %o1
40013148: 7f ff db 7d call 40009f3c <_Chain_Append>
4001314c: 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;
40013150: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
40013154: 82 10 60 01 or %g1, 1, %g1
40013158: c2 2e 60 30 stb %g1, [ %i1 + 0x30 ]
4001315c: 81 c7 e0 08 ret
40013160: 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) +
40013164: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 <== NOT EXECUTED
40013168: ba 00 7f fe add %g1, -2, %i5 <== NOT EXECUTED
4001316c: bb 2f 40 03 sll %i5, %g3, %i5 <== NOT EXECUTED
40013170: 10 bf ff e5 b 40013104 <fat_file_mark_removed+0x30> <== NOT EXECUTED
40013174: 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;
40013178: 10 bf ff e5 b 4001310c <fat_file_mark_removed+0x38> <== NOT EXECUTED
4001317c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
400124a8 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
400124a8: 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) +
400124ac: 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)
400124b0: 80 a0 60 01 cmp %g1, 1
400124b4: 02 80 00 9c be 40012724 <fat_file_open+0x27c>
400124b8: 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)) )
400124bc: 32 80 00 7b bne,a 400126a8 <fat_file_open+0x200>
400124c0: c6 0e 20 05 ldub [ %i0 + 5 ], %g3
400124c4: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
400124c8: 80 88 a0 03 btst 3, %g2
400124cc: 22 80 00 77 be,a 400126a8 <fat_file_open+0x200> <== NEVER TAKEN
400124d0: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
400124d4: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
400124d8: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
400124dc: bb 2f 40 02 sll %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400124e0: 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);
400124e4: de 06 20 6c ld [ %i0 + 0x6c ], %o7
400124e8: 85 30 60 09 srl %g1, 9, %g2
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
400124ec: 83 30 60 05 srl %g1, 5, %g1
400124f0: 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) +
400124f4: ba 07 40 02 add %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400124f8: 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) +
400124fc: 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;
40012500: 82 0f 60 01 and %i5, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
40012504: 85 28 60 02 sll %g1, 2, %g2
40012508: b7 28 60 04 sll %g1, 4, %i3
4001250c: 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;
40012510: c2 03 c0 1b ld [ %o7 + %i3 ], %g1
40012514: 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 ));
40012518: 9e 03 e0 04 add %o7, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4001251c: 80 a0 40 0f cmp %g1, %o7
40012520: 22 80 00 1e be,a 40012598 <fat_file_open+0xf0>
40012524: c4 06 20 70 ld [ %i0 + 0x70 ], %g2
40012528: 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)
4001252c: 80 a0 a0 01 cmp %g2, 1
40012530: 02 80 00 6d be 400126e4 <fat_file_open+0x23c>
40012534: 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)) )
40012538: 32 80 00 61 bne,a 400126bc <fat_file_open+0x214>
4001253c: c8 0e 20 05 ldub [ %i0 + 5 ], %g4
40012540: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3
40012544: 80 88 e0 03 btst 3, %g3
40012548: 22 80 00 5d be,a 400126bc <fat_file_open+0x214> <== NEVER TAKEN
4001254c: c8 0e 20 05 ldub [ %i0 + 5 ], %g4 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40012550: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
40012554: c6 0e 20 03 ldub [ %i0 + 3 ], %g3
40012558: b9 2f 00 03 sll %i4, %g3, %i4
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4001255c: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
40012560: 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) +
40012564: 89 30 e0 09 srl %g3, 9, %g4
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
40012568: 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) +
4001256c: 86 07 00 04 add %i4, %g4, %g3
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
40012570: 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) +
40012574: 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)
40012578: 80 a7 40 03 cmp %i5, %g3
4001257c: 22 80 00 55 be,a 400126d0 <fat_file_open+0x228>
40012580: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
40012584: 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) ; )
40012588: 80 a3 c0 01 cmp %o7, %g1
4001258c: 32 bf ff e8 bne,a 4001252c <fat_file_open+0x84>
40012590: 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);
40012594: 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;
40012598: c2 00 80 1b ld [ %g2 + %i3 ], %g1
4001259c: 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 ));
400125a0: 9e 00 a0 04 add %g2, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
400125a4: 80 a0 40 0f cmp %g1, %o7
400125a8: 02 80 00 1e be 40012620 <fat_file_open+0x178> <== ALWAYS TAKEN
400125ac: a0 10 3f ff mov -1, %l0
400125b0: 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)
400125b4: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
400125b8: 02 80 00 59 be 4001271c <fat_file_open+0x274> <== NOT EXECUTED
400125bc: 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)) )
400125c0: 32 80 00 4b bne,a 400126ec <fat_file_open+0x244> <== NOT EXECUTED
400125c4: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
400125c8: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3 <== NOT EXECUTED
400125cc: 80 88 e0 03 btst 3, %g3 <== NOT EXECUTED
400125d0: 22 80 00 47 be,a 400126ec <fat_file_open+0x244> <== NOT EXECUTED
400125d4: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
400125d8: 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) <<
400125dc: c8 0e 20 03 ldub [ %i0 + 3 ], %g4 <== NOT EXECUTED
400125e0: b9 2f 00 04 sll %i4, %g4, %i4 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400125e4: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
400125e8: 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) +
400125ec: 89 30 e0 09 srl %g3, 9, %g4 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
400125f0: 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) +
400125f4: 86 07 00 04 add %i4, %g4, %g3 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400125f8: 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) +
400125fc: 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)
40012600: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
40012604: 02 80 00 3f be 40012700 <fat_file_open+0x258> <== NOT EXECUTED
40012608: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
4001260c: 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) ; )
40012610: 80 a0 40 0f cmp %g1, %o7 <== NOT EXECUTED
40012614: 32 bf ff e8 bne,a 400125b4 <fat_file_open+0x10c> <== NOT EXECUTED
40012618: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
return 0;
}
}
the_node = the_node->next;
}
return -1;
4001261c: 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));
40012620: 7f ff ca b6 call 400050f8 <malloc>
40012624: 90 10 20 44 mov 0x44, %o0
40012628: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
4001262c: 80 a2 20 00 cmp %o0, 0
40012630: 02 80 00 46 be 40012748 <fat_file_open+0x2a0> <== NEVER TAKEN
40012634: b8 10 00 08 mov %o0, %i4
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
40012638: 92 10 20 00 clr %o1
4001263c: 40 00 2a 37 call 4001cf18 <memset>
40012640: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40012644: de 0f 20 30 ldub [ %i4 + 0x30 ], %o7
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
40012648: c8 06 40 00 ld [ %i1 ], %g4
4001264c: c6 06 60 04 ld [ %i1 + 4 ], %g3
40012650: c4 06 60 08 ld [ %i1 + 8 ], %g2
40012654: 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;
40012658: b2 0b ff fe and %o7, -2, %i1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
4001265c: 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;
40012660: 9e 10 20 01 mov 1, %o7
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40012664: 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;
40012668: de 27 20 08 st %o7, [ %i4 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4001266c: b2 10 3f ff mov -1, %i1
lfat_fd->dir_pos = *dir_pos;
40012670: 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;
40012674: f2 27 20 3c st %i1, [ %i4 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
40012678: c4 27 20 28 st %g2, [ %i4 + 0x28 ]
if ( rc != RC_OK )
4001267c: 80 a4 20 00 cmp %l0, 0
40012680: 02 80 00 2b be 4001272c <fat_file_open+0x284> <== NEVER TAKEN
40012684: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
lfat_fd->ino = key;
40012688: 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);
4001268c: 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 );
40012690: 92 10 00 1c mov %i4, %o1
40012694: 90 02 00 1b add %o0, %i3, %o0
40012698: 7f ff de 29 call 40009f3c <_Chain_Append>
4001269c: b0 10 20 00 clr %i0
400126a0: 81 c7 e0 08 ret
400126a4: 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) +
400126a8: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
400126ac: ba 00 7f fe add %g1, -2, %i5
400126b0: bb 2f 40 03 sll %i5, %g3, %i5
400126b4: 10 bf ff 89 b 400124d8 <fat_file_open+0x30>
400126b8: ba 07 40 02 add %i5, %g2, %i5
400126bc: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
400126c0: b8 00 bf fe add %g2, -2, %i4
400126c4: b9 2f 00 04 sll %i4, %g4, %i4
400126c8: 10 bf ff a3 b 40012554 <fat_file_open+0xac>
400126cc: 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;
400126d0: c2 26 80 00 st %g1, [ %i2 ]
lfat_fd->links_num++;
400126d4: 84 00 a0 01 inc %g2
400126d8: c4 20 60 08 st %g2, [ %g1 + 8 ]
400126dc: 81 c7 e0 08 ret
400126e0: 91 e8 20 00 restore %g0, 0, %o0
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
400126e4: 10 bf ff 9e b 4001255c <fat_file_open+0xb4>
400126e8: 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) +
400126ec: c8 06 20 34 ld [ %i0 + 0x34 ], %g4 <== NOT EXECUTED
400126f0: b8 00 bf fe add %g2, -2, %i4 <== NOT EXECUTED
400126f4: b9 2f 00 03 sll %i4, %g3, %i4 <== NOT EXECUTED
400126f8: 10 bf ff b9 b 400125dc <fat_file_open+0x134> <== NOT EXECUTED
400126fc: 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) )
40012700: 02 bf ff c8 be 40012620 <fat_file_open+0x178> <== NOT EXECUTED
40012704: a0 10 20 00 clr %l0 <== NOT EXECUTED
40012708: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
4001270c: 80 a7 40 02 cmp %i5, %g2 <== NOT EXECUTED
40012710: 32 bf ff c0 bne,a 40012610 <fat_file_open+0x168> <== NOT EXECUTED
40012714: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40012718: 30 bf ff c2 b,a 40012620 <fat_file_open+0x178> <== NOT EXECUTED
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
4001271c: 10 bf ff b2 b 400125e4 <fat_file_open+0x13c> <== NOT EXECUTED
40012720: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
40012724: 10 bf ff 6f b 400124e0 <fat_file_open+0x38>
40012728: 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);
4001272c: 40 00 07 23 call 400143b8 <fat_get_unique_ino> <== NOT EXECUTED
40012730: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
40012734: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012738: 12 bf ff d5 bne 4001268c <fat_file_open+0x1e4> <== NOT EXECUTED
4001273c: d0 27 20 0c st %o0, [ %i4 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
40012740: 7f ff c9 1b call 40004bac <free> <== NOT EXECUTED
40012744: 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 );
40012748: 40 00 27 12 call 4001c390 <__errno> <== NOT EXECUTED
4001274c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012750: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40012754: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012758: 81 c7 e0 08 ret <== NOT EXECUTED
4001275c: 81 e8 00 00 restore <== NOT EXECUTED
40012778 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
40012778: 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;
4001277c: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
40012780: 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)
40012784: 80 a6 e0 00 cmp %i3, 0
40012788: 02 80 00 7f be 40012984 <fat_file_read+0x20c> <== NEVER TAKEN
4001278c: 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 )
40012790: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40012794: 80 a0 40 1a cmp %g1, %i2
40012798: 08 80 00 7b bleu 40012984 <fat_file_read+0x20c>
4001279c: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
400127a0: 08 80 00 4c bleu 400128d0 <fat_file_read+0x158> <== ALWAYS TAKEN
400127a4: 84 20 40 1b sub %g1, %i3, %g2
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
400127a8: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
400127ac: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400127b0: 80 a0 60 01 cmp %g1, 1
400127b4: 22 80 00 4c be,a 400128e4 <fat_file_read+0x16c>
400127b8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
400127bc: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
400127c0: e0 17 60 06 lduh [ %i5 + 6 ], %l0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
400127c4: 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);
400127c8: 90 10 00 1d mov %i5, %o0
400127cc: 92 10 00 19 mov %i1, %o1
400127d0: 94 10 00 12 mov %l2, %o2
400127d4: 7f ff ff 06 call 400123ec <fat_file_lseek>
400127d8: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
400127dc: b0 92 60 00 orcc %o1, 0, %i0
400127e0: 12 80 00 69 bne 40012984 <fat_file_read+0x20c> <== NEVER TAKEN
400127e4: a1 2c 20 10 sll %l0, 0x10, %l0
return rc;
while (count > 0)
400127e8: 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);
400127ec: 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)
400127f0: 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);
400127f4: 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)
400127f8: 80 a6 e0 00 cmp %i3, 0
400127fc: 02 80 00 5b be 40012968 <fat_file_read+0x1f0> <== NEVER TAKEN
40012800: b4 0e 80 10 and %i2, %l0, %i2
40012804: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
40012808: c8 17 40 00 lduh [ %i5 ], %g4
4001280c: 10 80 00 20 b 4001288c <fat_file_read+0x114>
40012810: 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)) )
40012814: 80 8e 20 03 btst 3, %i0 <== NOT EXECUTED
40012818: 22 80 00 27 be,a 400128b4 <fat_file_read+0x13c> <== NOT EXECUTED
4001281c: de 0f 60 05 ldub [ %i5 + 5 ], %o7 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40012820: 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);
40012824: 87 32 80 03 srl %o2, %g3, %g3
byte = ofs & (fs_info->vol.bps - 1);
40012828: 85 29 20 10 sll %g4, 0x10, %g2
4001282c: 85 30 a0 10 srl %g2, 0x10, %g2
40012830: 84 00 bf ff add %g2, -1, %g2
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
40012834: 98 07 00 11 add %i4, %l1, %o4
40012838: 94 0a 80 02 and %o2, %g2, %o2
4001283c: 92 02 40 03 add %o1, %g3, %o1
40012840: 96 10 00 10 mov %l0, %o3
40012844: 40 00 03 25 call 400134d8 <_fat_block_read>
40012848: 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);
4001284c: 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 )
40012850: 80 a2 20 00 cmp %o0, 0
40012854: 06 80 00 3d bl 40012948 <fat_file_read+0x1d0> <== NEVER TAKEN
40012858: 90 10 00 1d mov %i5, %o0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
4001285c: 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;
40012860: 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);
40012864: 92 10 00 13 mov %l3, %o1
40012868: 40 00 1e 35 call 4001a13c <fat_get_fat_cluster>
4001286c: a2 04 40 10 add %l1, %l0, %l1
if ( rc != RC_OK )
40012870: 80 a2 20 00 cmp %o0, 0
40012874: 12 80 00 15 bne 400128c8 <fat_file_read+0x150> <== NEVER TAKEN
40012878: 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)
4001287c: 02 80 00 3a be 40012964 <fat_file_read+0x1ec>
40012880: 94 10 20 00 clr %o2
40012884: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
40012888: c8 17 40 00 lduh [ %i5 ], %g4
{
c = MIN(count, (fs_info->vol.bpc - ofs));
4001288c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
40012890: a0 24 00 0a sub %l0, %o2, %l0
40012894: 80 a4 00 1b cmp %l0, %i3
40012898: 08 80 00 03 bleu 400128a4 <fat_file_read+0x12c>
4001289c: c4 07 bf fc ld [ %fp + -4 ], %g2
400128a0: 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)) )
400128a4: 80 a0 a0 00 cmp %g2, 0
400128a8: 22 bf ff db be,a 40012814 <fat_file_read+0x9c> <== NEVER TAKEN
400128ac: 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) +
400128b0: de 0f 60 05 ldub [ %i5 + 5 ], %o7
400128b4: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
400128b8: 92 00 bf fe add %g2, -2, %o1
400128bc: 93 2a 40 0f sll %o1, %o7, %o1
400128c0: 10 bf ff d9 b 40012824 <fat_file_read+0xac>
400128c4: 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;
}
400128c8: 81 c7 e0 08 ret <== NOT EXECUTED
400128cc: 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) ||
400128d0: 80 a6 80 02 cmp %i2, %g2
400128d4: 28 bf ff b7 bleu,a 400127b0 <fat_file_read+0x38>
400128d8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
400128dc: 10 bf ff b4 b 400127ac <fat_file_read+0x34>
400128e0: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
400128e4: 80 a0 60 00 cmp %g1, 0
400128e8: 32 bf ff b6 bne,a 400127c0 <fat_file_read+0x48> <== NEVER TAKEN
400128ec: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
400128f0: 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)) &&
400128f4: 80 88 60 03 btst 3, %g1
400128f8: 22 bf ff b2 be,a 400127c0 <fat_file_read+0x48>
400128fc: 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);
40012900: 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)) )
40012904: 80 a0 60 00 cmp %g1, 0
40012908: 32 80 00 12 bne,a 40012950 <fat_file_read+0x1d8> <== NEVER TAKEN
4001290c: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40012910: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
sec += (start >> fs_info->vol.sec_log2);
40012914: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
byte = start & (fs_info->vol.bps - 1);
40012918: 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);
4001291c: 83 36 80 01 srl %i2, %g1, %g1
byte = start & (fs_info->vol.bps - 1);
40012920: 94 02 bf ff add %o2, -1, %o2
ret = _fat_block_read(fs_info, sec, byte, count, buf);
40012924: 90 10 00 1d mov %i5, %o0
40012928: 92 02 40 01 add %o1, %g1, %o1
4001292c: 94 0e 80 0a and %i2, %o2, %o2
40012930: 96 10 00 1b mov %i3, %o3
40012934: 40 00 02 e9 call 400134d8 <_fat_block_read>
40012938: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
4001293c: b0 92 20 00 orcc %o0, 0, %i0
40012940: 16 80 00 11 bge 40012984 <fat_file_read+0x20c> <== ALWAYS TAKEN
40012944: 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;
40012948: 81 c7 e0 08 ret <== NOT EXECUTED
4001294c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40012950: c4 07 60 34 ld [ %i5 + 0x34 ], %g2 <== NOT EXECUTED
40012954: 92 00 7f fe add %g1, -2, %o1 <== NOT EXECUTED
40012958: 93 2a 40 03 sll %o1, %g3, %o1 <== NOT EXECUTED
4001295c: 10 bf ff ee b 40012914 <fat_file_read+0x19c> <== NOT EXECUTED
40012960: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40012964: 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);
40012968: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
4001296c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
40012970: 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);
40012974: a2 06 80 11 add %i2, %l1, %l1
40012978: 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 +
4001297c: a4 04 40 12 add %l1, %l2, %l2
40012980: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
40012984: 81 c7 e0 08 ret
40012988: 81 e8 00 00 restore
40013180 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40013180: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
40013184: 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)) &&
40013188: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4001318c: 80 a0 60 01 cmp %g1, 1
40013190: 02 80 00 21 be 40013214 <fat_file_size+0x94>
40013194: 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)
40013198: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4001319c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400131a0: 84 0f 00 02 and %i4, %g2, %g2
400131a4: 80 a0 80 01 cmp %g2, %g1
400131a8: 0a 80 00 0e bcs 400131e0 <fat_file_size+0x60> <== ALWAYS TAKEN
400131ac: 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;
400131b0: 10 80 00 15 b 40013204 <fat_file_size+0x84> <== NOT EXECUTED
400131b4: 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;
400131b8: 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)
400131bc: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
400131c0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
400131c4: 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;
400131c8: 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)
400131cc: 86 08 40 03 and %g1, %g3, %g3
400131d0: 80 a0 c0 02 cmp %g3, %g2
400131d4: 1a 80 00 0c bcc 40013204 <fat_file_size+0x84> <== ALWAYS TAKEN
400131d8: c8 26 60 18 st %g4, [ %i1 + 0x18 ]
400131dc: b8 10 00 01 mov %g1, %i4 <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
400131e0: 92 10 00 1c mov %i4, %o1
400131e4: 90 10 00 18 mov %i0, %o0
400131e8: 40 00 1b d5 call 4001a13c <fat_get_fat_cluster>
400131ec: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
400131f0: 80 a2 20 00 cmp %o0, 0
400131f4: 22 bf ff f1 be,a 400131b8 <fat_file_size+0x38> <== ALWAYS TAKEN
400131f8: 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;
}
400131fc: 81 c7 e0 08 ret <== NOT EXECUTED
40013200: 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;
40013204: 90 10 20 00 clr %o0
40013208: f8 26 60 3c st %i4, [ %i1 + 0x3c ]
return rc;
}
4001320c: 81 c7 e0 08 ret
40013210: 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)) &&
40013214: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40013218: 80 a0 60 00 cmp %g1, 0
4001321c: 32 bf ff e0 bne,a 4001319c <fat_file_size+0x1c> <== NEVER TAKEN
40013220: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40013224: 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)) &&
40013228: 80 88 60 03 btst 3, %g1
4001322c: 22 bf ff dc be,a 4001319c <fat_file_size+0x1c> <== ALWAYS TAKEN
40013230: 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;
40013234: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
return rc;
40013238: 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;
4001323c: 10 bf ff f0 b 400131fc <fat_file_size+0x7c> <== NOT EXECUTED
40013240: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
4001298c <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
4001298c: 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 )
40012990: 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;
40012994: 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;
40012998: 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 )
4001299c: 80 a0 40 1a cmp %g1, %i2
400129a0: 08 80 00 26 bleu 40012a38 <fat_file_truncate+0xac>
400129a4: c4 27 bf fc st %g2, [ %fp + -4 ]
return rc;
assert(fat_fd->fat_file_size);
400129a8: 80 a0 60 00 cmp %g1, 0
400129ac: 02 80 00 31 be 40012a70 <fat_file_truncate+0xe4> <== NEVER TAKEN
400129b0: 11 10 00 b3 sethi %hi(0x4002cc00), %o0
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
400129b4: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
400129b8: c6 16 20 06 lduh [ %i0 + 6 ], %g3
400129bc: 86 00 ff ff add %g3, -1, %g3
400129c0: b4 00 c0 1a add %g3, %i2, %i2
400129c4: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
400129c8: 85 2e 80 02 sll %i2, %g2, %g2
400129cc: 80 a0 40 02 cmp %g1, %g2
400129d0: 08 80 00 1a bleu 40012a38 <fat_file_truncate+0xac>
400129d4: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
400129d8: 02 80 00 09 be 400129fc <fat_file_truncate+0x70>
400129dc: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
400129e0: 92 10 00 19 mov %i1, %o1
400129e4: 94 06 bf ff add %i2, -1, %o2
400129e8: 7f ff fe 81 call 400123ec <fat_file_lseek>
400129ec: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
400129f0: 80 a2 60 00 cmp %o1, 0
400129f4: 12 80 00 12 bne 40012a3c <fat_file_truncate+0xb0> <== NEVER TAKEN
400129f8: 90 10 00 18 mov %i0, %o0
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
400129fc: 92 10 00 19 mov %i1, %o1
40012a00: 94 10 00 1a mov %i2, %o2
40012a04: 7f ff fe 7a call 400123ec <fat_file_lseek>
40012a08: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
40012a0c: 80 a2 60 00 cmp %o1, 0
40012a10: 12 80 00 0b bne 40012a3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40012a14: 01 00 00 00 nop
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
40012a18: d2 07 bf f8 ld [ %fp + -8 ], %o1
40012a1c: 40 00 1e fe call 4001a614 <fat_free_fat_clusters_chain>
40012a20: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
40012a24: 92 92 20 00 orcc %o0, 0, %o1
40012a28: 12 80 00 05 bne 40012a3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40012a2c: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
40012a30: 12 80 00 05 bne 40012a44 <fat_file_truncate+0xb8>
40012a34: 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;
40012a38: 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;
}
40012a3c: 81 c7 e0 08 ret
40012a40: 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);
40012a44: 90 10 00 18 mov %i0, %o0
40012a48: 40 00 1e 41 call 4001a34c <fat_set_fat_cluster>
40012a4c: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
40012a50: 92 92 20 00 orcc %o0, 0, %o1
40012a54: 12 bf ff fa bne 40012a3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40012a58: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
40012a5c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
40012a60: 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;
40012a64: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
40012a68: 10 bf ff f5 b 40012a3c <fat_file_truncate+0xb0>
40012a6c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
40012a70: 15 10 00 b3 sethi %hi(0x4002cc00), %o2 <== NOT EXECUTED
40012a74: 17 10 00 b3 sethi %hi(0x4002cc00), %o3 <== NOT EXECUTED
40012a78: 90 12 20 c0 or %o0, 0xc0, %o0 <== NOT EXECUTED
40012a7c: 92 10 22 d1 mov 0x2d1, %o1 <== NOT EXECUTED
40012a80: 94 12 a1 20 or %o2, 0x120, %o2 <== NOT EXECUTED
40012a84: 7f ff c7 e6 call 40004a1c <__assert_func> <== NOT EXECUTED
40012a88: 96 12 e1 08 or %o3, 0x108, %o3 <== NOT EXECUTED
40012e70 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40012e70: 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;
40012e74: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40012e78: 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;
40012e7c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t file_cln_initial = fat_fd->map.file_cln;
40012e80: e4 06 60 34 ld [ %i1 + 0x34 ], %l2
uint32_t cln;
if ( count == 0 )
40012e84: 80 a6 e0 00 cmp %i3, 0
40012e88: 02 80 00 5d be 40012ffc <fat_file_write+0x18c> <== NEVER TAKEN
40012e8c: b0 10 20 00 clr %i0
return cmpltd;
if (start >= fat_fd->size_limit)
40012e90: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
40012e94: 80 a6 80 1d cmp %i2, %i5
40012e98: 1a 80 00 89 bcc 400130bc <fat_file_write+0x24c> <== NEVER TAKEN
40012e9c: ba 27 40 1a sub %i5, %i2, %i5
40012ea0: 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;
40012ea4: 18 80 00 58 bgu 40013004 <fat_file_write+0x194> <== ALWAYS TAKEN
40012ea8: 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);
40012eac: b6 07 40 1a add %i5, %i2, %i3 <== NOT EXECUTED
40012eb0: 94 40 20 00 addx %g0, 0, %o2 <== NOT EXECUTED
40012eb4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40012eb8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40012ebc: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40012ec0: 7f ff ff 57 call 40012c1c <fat_file_extend> <== NOT EXECUTED
40012ec4: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
if (RC_OK == rc)
40012ec8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40012ecc: 12 80 00 4c bne 40012ffc <fat_file_write+0x18c> <== NOT EXECUTED
40012ed0: 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))
40012ed4: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
40012ed8: 32 80 00 02 bne,a 40012ee0 <fat_file_write+0x70> <== NEVER TAKEN
40012edc: 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));
40012ee0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40012ee4: 80 a0 60 01 cmp %g1, 1
40012ee8: 02 80 00 5b be 40013054 <fat_file_write+0x1e4>
40012eec: 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;
40012ef0: 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;
40012ef4: 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;
40012ef8: 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);
40012efc: 90 10 00 10 mov %l0, %o0
40012f00: 92 10 00 19 mov %i1, %o1
40012f04: 94 10 00 15 mov %l5, %o2
40012f08: 7f ff fd 39 call 400123ec <fat_file_lseek>
40012f0c: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
40012f10: 80 a2 60 00 cmp %o1, 0
40012f14: 12 80 00 38 bne 40012ff4 <fat_file_write+0x184> <== NEVER TAKEN
40012f18: b0 92 60 00 orcc %o1, 0, %i0
{
file_cln_cnt = cur_cln - fat_fd->cln;
40012f1c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40012f20: 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);
40012f24: 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;
40012f28: 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);
40012f2c: 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;
40012f30: 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);
40012f34: 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;
40012f38: 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 */
40012f3c: 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;
40012f40: 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)
40012f44: 80 a7 60 00 cmp %i5, 0
40012f48: 22 80 00 21 be,a 40012fcc <fat_file_write+0x15c> <== NEVER TAKEN
40012f4c: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 <== NOT EXECUTED
40012f50: 80 a6 20 00 cmp %i0, 0
40012f54: 32 80 00 1e bne,a 40012fcc <fat_file_write+0x15c> <== NEVER TAKEN
40012f58: 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));
40012f5c: d6 14 20 06 lduh [ %l0 + 6 ], %o3
40012f60: 96 22 c0 11 sub %o3, %l1, %o3
40012f64: 80 a2 c0 1d cmp %o3, %i5
40012f68: 38 80 00 02 bgu,a 40012f70 <fat_file_write+0x100>
40012f6c: 96 10 00 1d mov %i5, %o3
if (file_cln_initial < file_cln_cnt)
40012f70: 80 a4 80 16 cmp %l2, %l6
40012f74: 2a 80 00 02 bcs,a 40012f7c <fat_file_write+0x10c>
40012f78: a6 10 20 01 mov 1, %l3
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
40012f7c: d2 07 bf fc ld [ %fp + -4 ], %o1
40012f80: 90 10 00 10 mov %l0, %o0
40012f84: 94 10 00 11 mov %l1, %o2
40012f88: 98 07 00 1b add %i4, %i3, %o4
40012f8c: 9a 0c e0 01 and %l3, 1, %o5
40012f90: 40 00 01 fe call 40013788 <fat_cluster_write>
40012f94: b0 10 3f ff mov -1, %i0
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
40012f98: 80 a2 20 00 cmp %o0, 0
40012f9c: 06 bf ff eb bl 40012f48 <fat_file_write+0xd8> <== NEVER TAKEN
40012fa0: 80 a7 60 00 cmp %i5, 0
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
40012fa4: ac 05 a0 01 inc %l6
bytes_to_write -= ret;
cmpltd += ret;
40012fa8: b6 06 c0 08 add %i3, %o0, %i3
save_cln = cur_cln;
if (0 < bytes_to_write)
40012fac: ba a7 40 08 subcc %i5, %o0, %i5
40012fb0: 12 80 00 22 bne 40013038 <fat_file_write+0x1c8>
40012fb4: e8 07 bf fc ld [ %fp + -4 ], %l4
40012fb8: 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)
40012fbc: 80 a7 60 00 cmp %i5, 0
40012fc0: 12 bf ff e4 bne 40012f50 <fat_file_write+0xe0> <== NEVER TAKEN
40012fc4: 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);
40012fc8: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
40012fcc: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
40012fd0: 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);
40012fd4: b4 06 80 1b add %i2, %i3, %i2
40012fd8: b5 36 80 01 srl %i2, %g1, %i2
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
40012fdc: 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)
40012fe0: 92 96 20 00 orcc %i0, 0, %o1
40012fe4: 12 80 00 03 bne 40012ff0 <fat_file_write+0x180> <== NEVER TAKEN
40012fe8: ea 26 60 34 st %l5, [ %i1 + 0x34 ]
return rc;
else
return cmpltd;
40012fec: 92 10 00 1b mov %i3, %o1
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
40012ff0: b0 92 60 00 orcc %o1, 0, %i0
40012ff4: 06 80 00 30 bl 400130b4 <fat_file_write+0x244> <== NEVER TAKEN
40012ff8: 01 00 00 00 nop
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
40012ffc: 81 c7 e0 08 ret
40013000: 81 e8 00 00 restore
40013004: 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);
40013008: 94 40 20 00 addx %g0, 0, %o2
4001300c: b6 07 40 1a add %i5, %i2, %i3
40013010: 90 10 00 10 mov %l0, %o0
40013014: 92 10 00 19 mov %i1, %o1
40013018: 96 10 00 1b mov %i3, %o3
4001301c: 7f ff ff 00 call 40012c1c <fat_file_extend>
40013020: 98 07 bf f8 add %fp, -8, %o4
if (RC_OK == rc)
40013024: b0 92 20 00 orcc %o0, 0, %i0
40013028: 12 bf ff f5 bne 40012ffc <fat_file_write+0x18c>
4001302c: 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))
40013030: 10 bf ff aa b 40012ed8 <fat_file_write+0x68>
40013034: 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);
40013038: 90 10 00 10 mov %l0, %o0
4001303c: 92 10 00 14 mov %l4, %o1
40013040: 94 07 bf fc add %fp, -4, %o2
40013044: 40 00 1c 3e call 4001a13c <fat_get_fat_cluster>
40013048: a2 10 20 00 clr %l1
4001304c: 10 bf ff be b 40012f44 <fat_file_write+0xd4>
40013050: 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));
40013054: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40013058: 80 a0 60 00 cmp %g1, 0
4001305c: 32 bf ff a6 bne,a 40012ef4 <fat_file_write+0x84> <== NEVER TAKEN
40013060: f6 0c 20 08 ldub [ %l0 + 8 ], %i3 <== NOT EXECUTED
40013064: 80 88 a0 03 btst 3, %g2
40013068: 22 bf ff a3 be,a 40012ef4 <fat_file_write+0x84>
4001306c: 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;
40013070: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
cln += (start >> fs_info->vol.bpc_log2);
40013074: d2 0c 20 08 ldub [ %l0 + 8 ], %o1
byte = start & (fs_info->vol.bpc -1);
40013078: 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);
4001307c: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bpc -1);
40013080: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
40013084: 90 10 00 10 mov %l0, %o0
40013088: 92 02 40 01 add %o1, %g1, %o1
4001308c: 94 0e 80 0a and %i2, %o2, %o2
40013090: 96 10 00 1d mov %i5, %o3
40013094: 98 10 00 1c mov %i4, %o4
40013098: 40 00 01 bc call 40013788 <fat_cluster_write>
4001309c: 9a 10 20 00 clr %o5
cln,
byte,
count,
buf,
false);
if (0 > ret)
400130a0: 80 a2 20 00 cmp %o0, 0
400130a4: 06 80 00 04 bl 400130b4 <fat_file_write+0x244> <== NEVER TAKEN
400130a8: 01 00 00 00 nop
rc = -1;
else
cmpltd = ret;
400130ac: 81 c7 e0 08 ret
400130b0: 91 e8 00 08 restore %g0, %o0, %o0
start,
count,
buf,
file_cln_initial);
if (0 > ret)
rc = -1;
400130b4: 81 c7 e0 08 ret <== NOT EXECUTED
400130b8: 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);
400130bc: 40 00 24 b5 call 4001c390 <__errno> <== NOT EXECUTED
400130c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400130c4: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
400130c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400130cc: 81 c7 e0 08 ret <== NOT EXECUTED
400130d0: 81 e8 00 00 restore <== NOT EXECUTED
4001a614 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
4001a614: 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)
4001a618: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4001a61c: 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;
4001a620: 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)
4001a624: 84 0e 40 02 and %i1, %g2, %g2
4001a628: 80 a0 80 01 cmp %g2, %g1
4001a62c: 1a 80 00 25 bcc 4001a6c0 <fat_free_fat_clusters_chain+0xac><== NEVER TAKEN
4001a630: ba 10 00 18 mov %i0, %i5
4001a634: b8 10 00 19 mov %i1, %i4
4001a638: b6 10 20 00 clr %i3
4001a63c: 10 80 00 0e b 4001a674 <fat_free_fat_clusters_chain+0x60>
4001a640: 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);
4001a644: 7f ff ff 42 call 4001a34c <fat_set_fat_cluster>
4001a648: 01 00 00 00 nop
if ( rc != RC_OK )
4001a64c: 80 a2 20 00 cmp %o0, 0
4001a650: 02 80 00 03 be 4001a65c <fat_free_fat_clusters_chain+0x48><== ALWAYS TAKEN
4001a654: f8 07 bf fc ld [ %fp + -4 ], %i4
4001a658: 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)
4001a65c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4001a660: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001a664: 84 0f 00 02 and %i4, %g2, %g2
4001a668: 80 a0 80 01 cmp %g2, %g1
4001a66c: 1a 80 00 17 bcc 4001a6c8 <fat_free_fat_clusters_chain+0xb4>
4001a670: b6 06 e0 01 inc %i3
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4001a674: 92 10 00 1c mov %i4, %o1
4001a678: 94 07 bf fc add %fp, -4, %o2
4001a67c: 7f ff fe b0 call 4001a13c <fat_get_fat_cluster>
4001a680: 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);
4001a684: 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);
4001a688: 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);
4001a68c: 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 )
4001a690: 80 a6 20 00 cmp %i0, 0
4001a694: 02 bf ff ec be 4001a644 <fat_free_fat_clusters_chain+0x30><== ALWAYS TAKEN
4001a698: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4001a69c: c2 07 60 44 ld [ %i5 + 0x44 ], %g1 <== NOT EXECUTED
4001a6a0: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4001a6a4: 02 80 00 03 be 4001a6b0 <fat_free_fat_clusters_chain+0x9c><== NOT EXECUTED
4001a6a8: 82 06 c0 01 add %i3, %g1, %g1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
4001a6ac: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001a6b0: 7f ff e2 e5 call 40013244 <fat_buf_release> <== NOT EXECUTED
4001a6b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a6b8: 81 c7 e0 08 ret <== NOT EXECUTED
4001a6bc: 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;
4001a6c0: 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;
4001a6c4: 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)
4001a6c8: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4001a6cc: 80 a0 7f ff cmp %g1, -1
4001a6d0: 02 80 00 04 be 4001a6e0 <fat_free_fat_clusters_chain+0xcc><== ALWAYS TAKEN
4001a6d4: f2 27 60 4c st %i1, [ %i5 + 0x4c ]
fs_info->vol.free_cls += freed_cls_cnt;
4001a6d8: 82 06 c0 01 add %i3, %g1, %g1 <== NOT EXECUTED
4001a6dc: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001a6e0: b0 10 00 1a mov %i2, %i0
4001a6e4: 7f ff e2 d8 call 40013244 <fat_buf_release>
4001a6e8: 90 10 00 1d mov %i5, %o0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
4001a6ec: 81 c7 e0 08 ret
4001a6f0: 81 e8 00 00 restore
400144a8 <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);
400144a8: c4 02 20 80 ld [ %o0 + 0x80 ], %g2 <== NOT EXECUTED
400144ac: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 <== NOT EXECUTED
400144b0: 92 22 40 02 sub %o1, %g2, %o1 <== NOT EXECUTED
400144b4: 85 32 60 03 srl %o1, 3, %g2 <== NOT EXECUTED
400144b8: c6 08 40 02 ldub [ %g1 + %g2 ], %g3 <== NOT EXECUTED
400144bc: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
400144c0: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
400144c4: 93 29 00 09 sll %g4, %o1, %o1 <== NOT EXECUTED
400144c8: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
400144cc: 81 c3 e0 08 retl <== NOT EXECUTED
400144d0: d2 28 40 02 stb %o1, [ %g1 + %g2 ] <== NOT EXECUTED
4001a13c <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
4001a13c: 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)) )
4001a140: 80 a6 60 01 cmp %i1, 1
4001a144: 08 80 00 27 bleu 4001a1e0 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
4001a148: ba 10 00 18 mov %i0, %i5
4001a14c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001a150: 82 00 60 01 inc %g1
4001a154: 80 a6 40 01 cmp %i1, %g1
4001a158: 18 80 00 22 bgu 4001a1e0 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
4001a15c: 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) +
4001a160: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001a164: 80 88 60 01 btst 1, %g1
4001a168: 12 80 00 24 bne 4001a1f8 <fat_get_fat_cluster+0xbc>
4001a16c: f6 0e 20 02 ldub [ %i0 + 2 ], %i3
4001a170: 82 08 60 02 and %g1, 2, %g1
4001a174: 80 88 60 ff btst 0xff, %g1
4001a178: 02 80 00 30 be 4001a238 <fat_get_fat_cluster+0xfc>
4001a17c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001a180: b9 2e 60 01 sll %i1, 1, %i4
4001a184: b7 37 00 1b srl %i4, %i3, %i3
4001a188: 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);
4001a18c: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001a190: 90 10 00 1d mov %i5, %o0
4001a194: 92 10 00 1b mov %i3, %o1
4001a198: 94 10 20 01 mov 1, %o2
4001a19c: 7f ff e4 a1 call 40013420 <fat_buf_access>
4001a1a0: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
4001a1a4: b0 92 20 00 orcc %o0, 0, %i0
4001a1a8: 12 80 00 57 bne 4001a304 <fat_get_fat_cluster+0x1c8> <== NEVER TAKEN
4001a1ac: 01 00 00 00 nop
return rc;
switch ( fs_info->vol.type )
4001a1b0: 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);
4001a1b4: 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 )
4001a1b8: 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);
4001a1bc: a1 34 20 10 srl %l0, 0x10, %l0
4001a1c0: 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 )
4001a1c4: 02 80 00 21 be 4001a248 <fat_get_fat_cluster+0x10c>
4001a1c8: b8 0f 00 10 and %i4, %l0, %i4
4001a1cc: 80 a0 60 04 cmp %g1, 4
4001a1d0: 02 80 00 3c be 4001a2c0 <fat_get_fat_cluster+0x184>
4001a1d4: 80 a0 60 01 cmp %g1, 1
4001a1d8: 02 80 00 28 be 4001a278 <fat_get_fat_cluster+0x13c> <== ALWAYS TAKEN
4001a1dc: 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);
4001a1e0: 40 00 08 6c call 4001c390 <__errno> <== NOT EXECUTED
4001a1e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a1e8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a1ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a1f0: 81 c7 e0 08 ret <== NOT EXECUTED
4001a1f4: 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) +
4001a1f8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001a1fc: 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);
4001a200: 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) +
4001a204: 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);
4001a208: 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) +
4001a20c: 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);
4001a210: 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) +
4001a214: 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);
4001a218: 96 07 bf fc add %fp, -4, %o3
4001a21c: 7f ff e4 81 call 40013420 <fat_buf_access>
4001a220: 92 10 00 1b mov %i3, %o1
if (rc != RC_OK)
4001a224: b0 92 20 00 orcc %o0, 0, %i0
4001a228: 22 bf ff e3 be,a 4001a1b4 <fat_get_fat_cluster+0x78> <== ALWAYS TAKEN
4001a22c: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
4001a230: 81 c7 e0 08 ret <== NOT EXECUTED
4001a234: 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) +
4001a238: b9 2e 60 02 sll %i1, 2, %i4
4001a23c: b7 37 00 1b srl %i4, %i3, %i3
4001a240: 10 bf ff d3 b 4001a18c <fat_get_fat_cluster+0x50>
4001a244: 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));
4001a248: c2 07 bf fc ld [ %fp + -4 ], %g1
*ret_val = CF_LE_W(*ret_val);
4001a24c: 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));
4001a250: c2 10 40 1c lduh [ %g1 + %i4 ], %g1
*ret_val = CF_LE_W(*ret_val);
4001a254: 86 10 e3 ff or %g3, 0x3ff, %g3
4001a258: 83 28 60 10 sll %g1, 0x10, %g1
4001a25c: 85 30 60 18 srl %g1, 0x18, %g2
4001a260: 83 30 60 08 srl %g1, 8, %g1
4001a264: 82 08 40 03 and %g1, %g3, %g1
4001a268: 82 10 80 01 or %g2, %g1, %g1
4001a26c: c2 26 80 00 st %g1, [ %i2 ]
break;
4001a270: 81 c7 e0 08 ret
4001a274: 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) )
4001a278: 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));
4001a27c: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
if ( ofs == (fs_info->vol.bps - 1) )
4001a280: 86 00 ff ff add %g3, -1, %g3
4001a284: 80 a0 c0 1c cmp %g3, %i4
4001a288: 02 80 00 21 be 4001a30c <fat_get_fat_cluster+0x1d0> <== NEVER TAKEN
4001a28c: c2 26 80 00 st %g1, [ %i2 ]
*ret_val |= *sec_buf << 8;
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
4001a290: b8 00 80 1c add %g2, %i4, %i4
4001a294: c4 0f 20 01 ldub [ %i4 + 1 ], %g2
4001a298: 85 28 a0 08 sll %g2, 8, %g2
4001a29c: 82 10 80 01 or %g2, %g1, %g1
4001a2a0: c2 26 80 00 st %g1, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
4001a2a4: 80 8e 60 01 btst 1, %i1
4001a2a8: 22 80 00 16 be,a 4001a300 <fat_get_fat_cluster+0x1c4>
4001a2ac: 82 08 6f ff and %g1, 0xfff, %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
4001a2b0: 83 30 60 04 srl %g1, 4, %g1
4001a2b4: c2 26 80 00 st %g1, [ %i2 ]
4001a2b8: 81 c7 e0 08 ret
4001a2bc: 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));
4001a2c0: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a2c4: c2 00 40 1c ld [ %g1 + %i4 ], %g1
4001a2c8: 89 28 60 18 sll %g1, 0x18, %g4
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
4001a2cc: 85 30 60 18 srl %g1, 0x18, %g2
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001a2d0: 87 30 60 08 srl %g1, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a2d4: 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;
4001a2d8: 86 08 e0 ff and %g3, 0xff, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001a2dc: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a2e0: 87 28 e0 10 sll %g3, 0x10, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001a2e4: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a2e8: 84 10 80 03 or %g2, %g3, %g2
4001a2ec: 83 28 60 08 sll %g1, 8, %g1
4001a2f0: 82 10 80 01 or %g2, %g1, %g1
*ret_val = CF_LE_L(*ret_val);
4001a2f4: c2 26 80 00 st %g1, [ %i2 ]
break;
4001a2f8: 81 c7 e0 08 ret
4001a2fc: 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;
4001a300: c2 26 80 00 st %g1, [ %i2 ]
4001a304: 81 c7 e0 08 ret
4001a308: 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,
4001a30c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a310: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
4001a314: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001a318: 7f ff e4 42 call 40013420 <fat_buf_access> <== NOT EXECUTED
4001a31c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
4001a320: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001a324: 12 80 00 08 bne 4001a344 <fat_get_fat_cluster+0x208> <== NOT EXECUTED
4001a328: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
4001a32c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
4001a330: c4 08 80 00 ldub [ %g2 ], %g2 <== NOT EXECUTED
4001a334: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4001a338: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
4001a33c: 10 bf ff da b 4001a2a4 <fat_get_fat_cluster+0x168> <== NOT EXECUTED
4001a340: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
4001a344: 81 c7 e0 08 ret <== NOT EXECUTED
4001a348: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400143b8 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
400143b8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
400143bc: 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))
400143c0: 33 03 ff ff sethi %hi(0xffffc00), %i1 <== NOT EXECUTED
400143c4: 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++)
400143c8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400143cc: 22 80 00 20 be,a 4001444c <fat_get_unique_ino+0x94> <== NOT EXECUTED
400143d0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
400143d4: c6 06 20 74 ld [ %i0 + 0x74 ], %g3 <== NOT EXECUTED
400143d8: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
400143dc: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
400143e0: c8 48 c0 02 ldsb [ %g3 + %g2 ], %g4 <== NOT EXECUTED
400143e4: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
400143e8: b4 00 c0 02 add %g3, %g2, %i2 <== NOT EXECUTED
400143ec: 89 39 00 1c sra %g4, %i4, %g4 <== NOT EXECUTED
400143f0: 80 89 20 01 btst 1, %g4 <== NOT EXECUTED
400143f4: 02 80 00 1d be 40014468 <fat_get_unique_ino+0xb0> <== NOT EXECUTED
400143f8: c4 08 c0 02 ldub [ %g3 + %g2 ], %g2 <== NOT EXECUTED
400143fc: 10 80 00 0a b 40014424 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
40014400: 88 10 20 00 clr %g4 <== NOT EXECUTED
40014404: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
40014408: f6 48 c0 02 ldsb [ %g3 + %g2 ], %i3 <== NOT EXECUTED
4001440c: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
40014410: b4 00 c0 02 add %g3, %g2, %i2 <== NOT EXECUTED
40014414: b7 3e c0 1c sra %i3, %i4, %i3 <== NOT EXECUTED
40014418: 80 8e e0 01 btst 1, %i3 <== NOT EXECUTED
4001441c: 02 80 00 13 be 40014468 <fat_get_unique_ino+0xb0> <== NOT EXECUTED
40014420: 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++;
40014424: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
40014428: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
4001442c: 0a 80 00 03 bcs 40014438 <fat_get_unique_ino+0x80> <== NOT EXECUTED
40014430: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
fs_info->index = 0;
40014434: 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++)
40014438: 88 01 20 01 inc %g4 <== NOT EXECUTED
4001443c: 80 a1 00 1d cmp %g4, %i5 <== NOT EXECUTED
40014440: 32 bf ff f1 bne,a 40014404 <fat_get_unique_ino+0x4c> <== NOT EXECUTED
40014444: 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))
40014448: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
4001444c: 93 2f 60 01 sll %i5, 1, %o1 <== NOT EXECUTED
40014450: 82 26 40 01 sub %i1, %g1, %g1 <== NOT EXECUTED
40014454: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
40014458: 2a 80 00 0c bcs,a 40014488 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
4001445c: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
40014460: 81 c7 e0 08 ret <== NOT EXECUTED
40014464: 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);
40014468: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001446c: b9 28 40 1c sll %g1, %i4, %i4 <== NOT EXECUTED
40014470: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
40014474: c4 2e 80 00 stb %g2, [ %i2 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
40014478: c4 06 20 78 ld [ %i0 + 0x78 ], %g2 <== NOT EXECUTED
4001447c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40014480: 81 c7 e0 08 ret <== NOT EXECUTED
40014484: 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);
40014488: 7f ff c5 ce call 40005bc0 <realloc> <== NOT EXECUTED
4001448c: d2 26 20 7c st %o1, [ %i0 + 0x7c ] <== NOT EXECUTED
if (fs_info->uino != NULL)
40014490: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014494: 02 bf ff f3 be 40014460 <fat_get_unique_ino+0xa8> <== NOT EXECUTED
40014498: d0 26 20 74 st %o0, [ %i0 + 0x74 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
4001449c: fa 06 20 7c ld [ %i0 + 0x7c ], %i5 <== NOT EXECUTED
400144a0: 10 bf ff ca b 400143c8 <fat_get_unique_ino+0x10> <== NOT EXECUTED
400144a4: fa 26 20 78 st %i5, [ %i0 + 0x78 ] <== NOT EXECUTED
4001433c <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
4001433c: 9d e3 bf 98 save %sp, -104, %sp
40014340: 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)
40014344: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40014348: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4001434c: 92 10 00 19 mov %i1, %o1
40014350: 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)
40014354: b2 0e 40 02 and %i1, %g2, %i1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40014358: 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)
4001435c: 80 a6 40 01 cmp %i1, %g1
40014360: 1a 80 00 10 bcc 400143a0 <fat_init_clusters_chain+0x64>
40014364: 90 10 00 18 mov %i0, %o0
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40014368: 7f ff fc a8 call 40013608 <fat_cluster_set>
4001436c: d6 16 20 06 lduh [ %i0 + 6 ], %o3
if ( ret != fs_info->vol.bpc )
40014370: c2 16 20 06 lduh [ %i0 + 6 ], %g1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40014374: 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 )
40014378: 80 a0 40 08 cmp %g1, %o0
4001437c: 12 80 00 0c bne 400143ac <fat_init_clusters_chain+0x70> <== NEVER TAKEN
40014380: 90 10 00 18 mov %i0, %o0
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40014384: 40 00 17 6e call 4001a13c <fat_get_fat_cluster>
40014388: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
4001438c: 80 a2 20 00 cmp %o0, 0
40014390: 02 bf ff ed be 40014344 <fat_init_clusters_chain+0x8> <== ALWAYS TAKEN
40014394: f2 07 bf fc ld [ %fp + -4 ], %i1
}
}
return rc;
}
40014398: 81 c7 e0 08 ret <== NOT EXECUTED
4001439c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
return rc;
}
}
return rc;
400143a0: 90 10 20 00 clr %o0
}
400143a4: 81 c7 e0 08 ret
400143a8: 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;
400143ac: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
}
}
return rc;
}
400143b0: 81 c7 e0 08 ret <== NOT EXECUTED
400143b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40013910 <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)
{
40013910: 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);
40013914: 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;
40013918: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
4001391c: 7f ff c8 0c call 4000594c <open>
40013920: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
40013924: 80 a2 20 00 cmp %o0, 0
40013928: 06 80 01 c1 bl 4001402c <fat_init_volume_info+0x71c> <== NEVER TAKEN
4001392c: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
40013930: 7f ff c4 c9 call 40004c54 <fstat>
40013934: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
40013938: 80 a2 20 00 cmp %o0, 0
4001393c: 12 80 01 b9 bne 40014020 <fat_init_volume_info+0x710> <== NEVER TAKEN
40013940: 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))
40013944: 05 00 00 3c sethi %hi(0xf000), %g2
40013948: 86 08 c0 02 and %g3, %g2, %g3
4001394c: 05 00 00 18 sethi %hi(0x6000), %g2
40013950: 80 a0 c0 02 cmp %g3, %g2
40013954: 12 80 01 b4 bne 40014024 <fat_init_volume_info+0x714> <== NEVER TAKEN
40013958: 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);
4001395c: 94 06 20 64 add %i0, 0x64, %o2
40013960: 13 10 01 10 sethi %hi(0x40044000), %o1
40013964: 40 00 05 c6 call 4001507c <ioctl>
40013968: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x15179>
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) {
4001396c: 80 a2 20 00 cmp %o0, 0
40013970: 12 80 01 ac bne 40014020 <fat_init_volume_info+0x710> <== NEVER TAKEN
40013974: 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);
40013978: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
4001397c: 7f ff f5 c8 call 4001109c <rtems_bdbuf_read>
40013980: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
40013984: 80 a2 20 00 cmp %o0, 0
40013988: 12 80 01 b5 bne 4001405c <fat_init_volume_info+0x74c> <== NEVER TAKEN
4001398c: 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);
40013990: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
40013994: c2 08 a0 20 ldub [ %g2 + 0x20 ], %g1
40013998: f8 08 a0 0b ldub [ %g2 + 0xb ], %i4
4001399c: c2 2f bf 93 stb %g1, [ %fp + -109 ]
400139a0: c2 08 a0 21 ldub [ %g2 + 0x21 ], %g1
400139a4: f6 08 a0 0c ldub [ %g2 + 0xc ], %i3
400139a8: c2 2f bf 95 stb %g1, [ %fp + -107 ]
400139ac: c2 08 a0 22 ldub [ %g2 + 0x22 ], %g1
400139b0: ec 08 a0 0d ldub [ %g2 + 0xd ], %l6
400139b4: c2 2f bf 94 stb %g1, [ %fp + -108 ]
400139b8: c2 08 a0 23 ldub [ %g2 + 0x23 ], %g1
400139bc: e8 08 a0 0e ldub [ %g2 + 0xe ], %l4
400139c0: c2 2f bf 8f stb %g1, [ %fp + -113 ]
400139c4: c2 08 a0 25 ldub [ %g2 + 0x25 ], %g1
400139c8: ea 08 a0 0f ldub [ %g2 + 0xf ], %l5
400139cc: c2 2f bf 97 stb %g1, [ %fp + -105 ]
400139d0: c2 08 a0 26 ldub [ %g2 + 0x26 ], %g1
400139d4: fa 08 a0 10 ldub [ %g2 + 0x10 ], %i5
400139d8: c2 2f bf 96 stb %g1, [ %fp + -106 ]
400139dc: c2 08 a0 27 ldub [ %g2 + 0x27 ], %g1
400139e0: f4 08 a0 11 ldub [ %g2 + 0x11 ], %i2
400139e4: c2 2f bf 9f stb %g1, [ %fp + -97 ]
400139e8: c2 08 a0 28 ldub [ %g2 + 0x28 ], %g1
400139ec: f2 08 a0 12 ldub [ %g2 + 0x12 ], %i1
400139f0: c2 2f bf 87 stb %g1, [ %fp + -121 ]
400139f4: c2 08 a0 2c ldub [ %g2 + 0x2c ], %g1
400139f8: e0 08 a0 13 ldub [ %g2 + 0x13 ], %l0
400139fc: c2 2f bf 90 stb %g1, [ %fp + -112 ]
40013a00: c2 08 a0 2d ldub [ %g2 + 0x2d ], %g1
40013a04: e2 08 a0 14 ldub [ %g2 + 0x14 ], %l1
40013a08: e4 08 a0 16 ldub [ %g2 + 0x16 ], %l2
40013a0c: e6 08 a0 17 ldub [ %g2 + 0x17 ], %l3
40013a10: ee 08 a0 24 ldub [ %g2 + 0x24 ], %l7
40013a14: c2 2f bf 7f stb %g1, [ %fp + -129 ]
40013a18: c2 08 a0 2e ldub [ %g2 + 0x2e ], %g1
40013a1c: c2 2f bf 7e stb %g1, [ %fp + -130 ]
40013a20: c2 08 a0 2f ldub [ %g2 + 0x2f ], %g1
40013a24: c2 2f bf 77 stb %g1, [ %fp + -137 ]
40013a28: c2 08 a0 30 ldub [ %g2 + 0x30 ], %g1
40013a2c: c4 08 a0 31 ldub [ %g2 + 0x31 ], %g2
40013a30: c2 2f bf 92 stb %g1, [ %fp + -110 ]
sc = rtems_bdbuf_release( block);
40013a34: 7f ff f6 1f call 400112b0 <rtems_bdbuf_release>
40013a38: c4 2f bf 91 stb %g2, [ %fp + -111 ]
if (sc != RTEMS_SUCCESSFUL)
40013a3c: 80 a2 20 00 cmp %o0, 0
40013a40: 12 80 01 87 bne 4001405c <fat_init_volume_info+0x74c> <== NEVER TAKEN
40013a44: 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);
40013a48: b8 0f 20 ff and %i4, 0xff, %i4
40013a4c: b7 2e e0 08 sll %i3, 8, %i3
40013a50: b8 16 c0 1c or %i3, %i4, %i4
40013a54: f8 36 00 00 sth %i4, [ %i0 ]
if ( (vol->bps != 512) &&
40013a58: 93 2f 20 10 sll %i4, 0x10, %o1
40013a5c: 85 32 60 10 srl %o1, 0x10, %g2
40013a60: 80 a0 a4 00 cmp %g2, 0x400
40013a64: 12 80 00 dc bne 40013dd4 <fat_init_volume_info+0x4c4> <== ALWAYS TAKEN
40013a68: 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;
40013a6c: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
40013a70: 80 88 a0 01 btst 1, %g2
40013a74: 12 80 00 0a bne 40013a9c <fat_init_volume_info+0x18c> <== ALWAYS TAKEN
40013a78: 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)
{
40013a7c: 10 80 00 03 b 40013a88 <fat_init_volume_info+0x178> <== NOT EXECUTED
40013a80: 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;
40013a84: 88 10 00 01 mov %g1, %g4 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
40013a88: 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;
40013a8c: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
40013a90: 02 bf ff fd be 40013a84 <fat_init_volume_info+0x174> <== NOT EXECUTED
40013a94: 82 01 20 01 add %g4, 1, %g1 <== NOT EXECUTED
40013a98: 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;
40013a9c: c0 2e 20 02 clrb [ %i0 + 2 ]
40013aa0: 93 32 60 10 srl %o1, 0x10, %o1
40013aa4: b6 10 20 01 mov 1, %i3
40013aa8: 80 8f 20 01 btst 1, %i4
40013aac: 02 80 00 05 be 40013ac0 <fat_init_volume_info+0x1b0> <== ALWAYS TAKEN
40013ab0: 84 10 00 09 mov %o1, %g2
40013ab4: 10 80 01 66 b 4001404c <fat_init_volume_info+0x73c> <== NOT EXECUTED
40013ab8: b6 10 20 00 clr %i3 <== NOT EXECUTED
40013abc: b6 10 00 01 mov %g1, %i3
i >>= 1, vol->sec_log2++);
40013ac0: 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;
40013ac4: 80 88 a0 01 btst 1, %g2
40013ac8: 02 bf ff fd be 40013abc <fat_init_volume_info+0x1ac>
40013acc: 82 06 e0 01 add %i3, 1, %g1
40013ad0: 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;
40013ad4: 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;
40013ad8: da 36 20 0a sth %o5, [ %i0 + 0xa ]
vol->bytes_per_block_log2 = vol->sec_log2;
40013adc: f6 2e 20 0c stb %i3, [ %i0 + 0xc ]
vol->sectors_per_block = 1;
40013ae0: 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)
40013ae4: b8 8d a0 ff andcc %l6, 0xff, %i4
40013ae8: 02 80 01 45 be 40013ffc <fat_init_volume_info+0x6ec> <== NEVER TAKEN
40013aec: 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;
40013af0: c0 2e 20 05 clrb [ %i0 + 5 ]
40013af4: 80 8d a0 01 btst 1, %l6
40013af8: 12 80 01 57 bne 40014054 <fat_init_volume_info+0x744>
40013afc: 84 10 00 1c mov %i4, %g2
40013b00: 10 80 00 03 b 40013b0c <fat_init_volume_info+0x1fc>
40013b04: 86 10 20 01 mov 1, %g3
40013b08: 86 10 00 01 mov %g1, %g3
i >>= 1, vol->spc_log2++);
40013b0c: 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;
40013b10: 80 88 a0 01 btst 1, %g2
40013b14: 02 bf ff fd be 40013b08 <fat_init_volume_info+0x1f8>
40013b18: 82 00 e0 01 add %g3, 1, %g1
40013b1c: c6 2e 20 05 stb %g3, [ %i0 + 5 ]
40013b20: 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)
40013b24: 87 2a 40 03 sll %o1, %g3, %g3
40013b28: 89 28 e0 10 sll %g3, 0x10, %g4
40013b2c: 05 20 00 00 sethi %hi(0x80000000), %g2
40013b30: 80 a1 00 02 cmp %g4, %g2
40013b34: 18 80 01 32 bgu 40013ffc <fat_init_volume_info+0x6ec> <== NEVER TAKEN
40013b38: 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;
40013b3c: c0 2e 20 08 clrb [ %i0 + 8 ]
40013b40: 05 00 00 3f sethi %hi(0xfc00), %g2
40013b44: 88 10 20 01 mov 1, %g4
40013b48: 84 10 a3 ff or %g2, 0x3ff, %g2
40013b4c: 80 88 e0 01 btst 1, %g3
40013b50: 02 80 00 05 be 40013b64 <fat_init_volume_info+0x254> <== ALWAYS TAKEN
40013b54: 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);
40013b58: 10 80 00 09 b 40013b7c <fat_init_volume_info+0x26c> <== NOT EXECUTED
40013b5c: 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;
40013b60: 88 10 00 01 mov %g1, %g4
i >>= 1, vol->bpc_log2++);
40013b64: 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;
40013b68: 80 88 a0 01 btst 1, %g2
40013b6c: 02 bf ff fd be 40013b60 <fat_init_volume_info+0x250>
40013b70: 82 01 20 01 add %g4, 1, %g1
40013b74: 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);
40013b78: b4 0e a0 ff and %i2, 0xff, %i2
40013b7c: b2 0e 60 ff and %i1, 0xff, %i1
40013b80: b3 2e 60 08 sll %i1, 8, %i1
40013b84: 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)) /
40013b88: 87 2e 60 10 sll %i1, 0x10, %g3
40013b8c: 87 30 e0 0b srl %g3, 0xb, %g3
40013b90: 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);
40013b94: fa 2e 20 0d stb %i5, [ %i0 + 0xd ]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
40013b98: aa 0d 60 ff and %l5, 0xff, %l5
40013b9c: a8 0d 20 ff and %l4, 0xff, %l4
40013ba0: ab 2d 60 08 sll %l5, 8, %l5
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40013ba4: 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);
40013ba8: 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)) /
40013bac: 90 00 c0 08 add %g3, %o0, %o0
40013bb0: 7f ff ba b3 call 4000267c <.div>
40013bb4: e8 36 20 18 sth %l4, [ %i0 + 0x18 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
40013bb8: 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)) /
40013bbc: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
40013bc0: 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)
40013bc4: a4 0c a0 ff and %l2, 0xff, %l2
40013bc8: 90 0c e0 ff and %l3, 0xff, %o0
40013bcc: 91 2a 20 08 sll %o0, 8, %o0
40013bd0: 90 12 00 12 or %o0, %l2, %o0
40013bd4: 91 2a 20 10 sll %o0, 0x10, %o0
40013bd8: 80 a2 20 00 cmp %o0, 0
40013bdc: 02 80 00 8a be 40013e04 <fat_init_volume_info+0x4f4>
40013be0: f6 26 20 2c st %i3, [ %i0 + 0x2c ]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
40013be4: 91 32 20 10 srl %o0, 0x10, %o0
40013be8: 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 +
40013bec: 92 0f 60 ff and %i5, 0xff, %o1
40013bf0: 7f ff ba 67 call 4000258c <.umul>
40013bf4: a9 2d 20 10 sll %l4, 0x10, %l4
40013bf8: a9 35 20 10 srl %l4, 0x10, %l4
40013bfc: 90 02 00 14 add %o0, %l4, %o0
40013c00: 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;
40013c04: d0 26 20 20 st %o0, [ %i0 + 0x20 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
40013c08: 90 0c 60 ff and %l1, 0xff, %o0
40013c0c: a0 0c 20 ff and %l0, 0xff, %l0
40013c10: 91 2a 20 08 sll %o0, 8, %o0
40013c14: 90 12 00 10 or %o0, %l0, %o0
40013c18: 91 2a 20 10 sll %o0, 0x10, %o0
40013c1c: 80 a2 20 00 cmp %o0, 0
40013c20: 02 80 00 e3 be 40013fac <fat_init_volume_info+0x69c>
40013c24: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
40013c28: 91 32 20 10 srl %o0, 0x10, %o0
40013c2c: 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;
40013c30: 90 22 00 1a sub %o0, %i2, %o0
40013c34: 7f ff ba 90 call 40002674 <.udiv>
40013c38: 92 10 00 1c mov %i4, %o1
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
40013c3c: 80 a2 2f f4 cmp %o0, 0xff4
40013c40: 18 80 00 7d bgu 40013e34 <fat_init_volume_info+0x524>
40013c44: d0 26 20 38 st %o0, [ %i0 + 0x38 ]
{
vol->type = FAT_FAT12;
40013c48: 84 10 20 01 mov 1, %g2
40013c4c: c4 2e 20 0e stb %g2, [ %i0 + 0xe ]
vol->mask = FAT_FAT12_MASK;
40013c50: 84 10 2f ff mov 0xfff, %g2
40013c54: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT12_EOC;
40013c58: 84 10 2f f8 mov 0xff8, %g2
40013c5c: 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;
40013c60: 84 10 3f ff mov -1, %g2
}
}
}
else
{
vol->rdir_cl = 0;
40013c64: c0 26 20 3c clr [ %i0 + 0x3c ]
vol->mirror = 0;
40013c68: c0 2e 20 54 clrb [ %i0 + 0x54 ]
vol->afat = 0;
40013c6c: c0 2e 20 5c clrb [ %i0 + 0x5c ]
vol->free_cls = FAT_UNDEFINED_VALUE;
40013c70: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
vol->next_cl = FAT_UNDEFINED_VALUE;
40013c74: 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);
40013c78: 7f ff fd 73 call 40013244 <fat_buf_release>
40013c7c: 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;
40013c80: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
40013c84: 7f ff ba 42 call 4000258c <.umul>
40013c88: d0 0e 20 5c ldub [ %i0 + 0x5c ], %o0
40013c8c: 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));
40013c90: 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;
40013c94: 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));
40013c98: 90 10 20 02 mov 2, %o0
40013c9c: 7f ff c3 8d call 40004ad0 <calloc>
40013ca0: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
if ( fs_info->vhash == NULL )
40013ca4: 80 a2 20 00 cmp %o0, 0
40013ca8: 02 80 01 03 be 400140b4 <fat_init_volume_info+0x7a4> <== NEVER TAKEN
40013cac: 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 );
40013cb0: 88 02 20 04 add %o0, 4, %g4
40013cb4: 84 02 20 0c add %o0, 0xc, %g2
40013cb8: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
40013cbc: c8 22 00 00 st %g4, [ %o0 ]
head->previous = NULL;
40013cc0: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40013cc4: 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;
40013cc8: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
40013ccc: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
40013cd0: 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));
40013cd4: 92 10 20 0c mov 0xc, %o1
40013cd8: 7f ff c3 7e call 40004ad0 <calloc>
40013cdc: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
40013ce0: 80 a2 20 00 cmp %o0, 0
40013ce4: 02 80 01 0c be 40014114 <fat_init_volume_info+0x804> <== NEVER TAKEN
40013ce8: 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;
40013cec: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
40013cf0: 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 );
40013cf4: 86 02 20 0c add %o0, 0xc, %g3
head->next = tail;
head->previous = NULL;
40013cf8: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40013cfc: 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;
40013d00: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
40013d04: 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 );
40013d08: 88 02 20 10 add %o0, 0x10, %g4
40013d0c: ba 02 20 04 add %o0, 4, %i5
head->next = tail;
40013d10: c8 22 20 0c st %g4, [ %o0 + 0xc ]
40013d14: fa 22 00 00 st %i5, [ %o0 ]
40013d18: 85 2f 00 02 sll %i4, %g2, %g2
40013d1c: 85 28 a0 04 sll %g2, 4, %g2
40013d20: 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;
40013d24: 84 10 21 00 mov 0x100, %g2
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
40013d28: 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;
40013d2c: 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));
40013d30: 90 10 21 00 mov 0x100, %o0
40013d34: 7f ff c3 67 call 40004ad0 <calloc>
40013d38: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
40013d3c: 80 a2 20 00 cmp %o0, 0
40013d40: 02 80 00 d0 be 40014080 <fat_init_volume_info+0x770> <== NEVER TAKEN
40013d44: 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));
40013d48: d0 16 00 00 lduh [ %i0 ], %o0
40013d4c: 7f ff c3 61 call 40004ad0 <calloc>
40013d50: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
40013d54: 80 a2 20 00 cmp %o0, 0
40013d58: 02 80 00 e7 be 400140f4 <fat_init_volume_info+0x7e4> <== NEVER TAKEN
40013d5c: 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;
40013d60: c4 0e 20 04 ldub [ %i0 + 4 ], %g2
40013d64: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
40013d68: 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)
40013d6c: 80 88 80 03 btst %g2, %g3
40013d70: 12 80 00 17 bne 40013dcc <fat_init_volume_info+0x4bc> <== NEVER TAKEN
40013d74: 01 00 00 00 nop
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40013d78: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3
40013d7c: 80 a0 e0 04 cmp %g3, 4
40013d80: 22 80 00 07 be,a 40013d9c <fat_init_volume_info+0x48c>
40013d84: 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;
40013d88: 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)))
40013d8c: 80 88 80 03 btst %g2, %g3
40013d90: 12 80 00 0f bne 40013dcc <fat_init_volume_info+0x4bc> <== NEVER TAKEN
40013d94: 01 00 00 00 nop
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
40013d98: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
40013d9c: d2 16 20 06 lduh [ %i0 + 6 ], %o1
40013da0: 7f ff f6 83 call 400117ac <rtems_bdbuf_set_block_size>
40013da4: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
40013da8: 80 a2 20 00 cmp %o0, 0
40013dac: 12 80 00 08 bne 40013dcc <fat_init_volume_info+0x4bc> <== NEVER TAKEN
40013db0: 01 00 00 00 nop
{
vol->bytes_per_block = vol->bpc;
40013db4: c8 16 20 06 lduh [ %i0 + 6 ], %g4
vol->bytes_per_block_log2 = vol->bpc_log2;
40013db8: c6 0e 20 08 ldub [ %i0 + 8 ], %g3
vol->sectors_per_block = vol->spc;
40013dbc: 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;
40013dc0: c8 36 20 0a sth %g4, [ %i0 + 0xa ]
vol->bytes_per_block_log2 = vol->bpc_log2;
40013dc4: c6 2e 20 0c stb %g3, [ %i0 + 0xc ]
vol->sectors_per_block = vol->spc;
40013dc8: c4 2e 20 09 stb %g2, [ %i0 + 9 ]
}
}
return RC_OK;
40013dcc: 81 c7 e0 08 ret
40013dd0: 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) &&
40013dd4: 80 a0 a2 00 cmp %g2, 0x200
40013dd8: 22 bf ff 26 be,a 40013a70 <fat_init_volume_info+0x160> <== ALWAYS TAKEN
40013ddc: 85 32 60 19 srl %o1, 0x19, %g2
(vol->bps != 1024) &&
40013de0: 80 a0 a8 00 cmp %g2, 0x800 <== NOT EXECUTED
40013de4: 22 bf ff 26 be,a 40013a7c <fat_init_volume_info+0x16c> <== NOT EXECUTED
40013de8: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
(vol->bps != 2048) &&
40013dec: 09 00 00 04 sethi %hi(0x1000), %g4 <== NOT EXECUTED
40013df0: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
40013df4: 12 80 00 82 bne 40013ffc <fat_init_volume_info+0x6ec> <== NOT EXECUTED
40013df8: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
40013dfc: 10 bf ff 23 b 40013a88 <fat_init_volume_info+0x178> <== NOT EXECUTED
40013e00: 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);
40013e04: c4 0f bf 96 ldub [ %fp + -106 ], %g2
40013e08: d0 0f bf 97 ldub [ %fp + -105 ], %o0
40013e0c: c2 0f bf 9f ldub [ %fp + -97 ], %g1
40013e10: 85 28 a0 10 sll %g2, 0x10, %g2
40013e14: 91 2a 20 08 sll %o0, 8, %o0
40013e18: ae 0d e0 ff and %l7, 0xff, %l7
40013e1c: 90 12 00 02 or %o0, %g2, %o0
40013e20: 85 28 60 18 sll %g1, 0x18, %g2
40013e24: 90 12 00 17 or %o0, %l7, %o0
40013e28: 90 12 00 02 or %o0, %g2, %o0
40013e2c: 10 bf ff 70 b 40013bec <fat_init_volume_info+0x2dc>
40013e30: 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)
40013e34: 05 00 00 3f sethi %hi(0xfc00), %g2
40013e38: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4>
40013e3c: 80 a2 00 03 cmp %o0, %g3
40013e40: 08 80 00 67 bleu 40013fdc <fat_init_volume_info+0x6cc>
40013e44: 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;
40013e48: c2 0f bf 87 ldub [ %fp + -121 ], %g1
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e4c: f8 0f bf 7f ldub [ %fp + -129 ], %i4
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40013e50: 84 08 7f 80 and %g1, -128, %g2
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e54: f6 0f bf 90 ldub [ %fp + -112 ], %i3
40013e58: c8 0f bf 7e ldub [ %fp + -130 ], %g4
40013e5c: c2 0f bf 77 ldub [ %fp + -137 ], %g1
40013e60: b9 2f 20 08 sll %i4, 8, %i4
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
40013e64: 07 03 ff ff sethi %hi(0xffffc00), %g3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e68: 89 29 20 10 sll %g4, 0x10, %g4
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
40013e6c: ba 10 e3 ff or %g3, 0x3ff, %i5
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e70: 88 17 00 04 or %i4, %g4, %g4
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
vol->eoc_val = FAT_FAT32_EOC;
40013e74: 86 10 e3 f8 or %g3, 0x3f8, %g3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e78: 88 11 00 1b or %g4, %i3, %g4
40013e7c: b9 28 60 18 sll %g1, 0x18, %i4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
40013e80: b6 10 20 04 mov 4, %i3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e84: 88 11 00 1c or %g4, %i4, %g4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
40013e88: f6 2e 20 0e stb %i3, [ %i0 + 0xe ]
vol->mask = FAT_FAT32_MASK;
40013e8c: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT32_EOC;
40013e90: c6 26 20 14 st %g3, [ %i0 + 0x14 ]
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40013e94: 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)
40013e98: 80 88 a0 80 btst 0x80, %g2
40013e9c: 02 80 00 6a be 40014044 <fat_init_volume_info+0x734> <== ALWAYS TAKEN
40013ea0: c4 2e 20 54 stb %g2, [ %i0 + 0x54 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
40013ea4: c2 0f bf 87 ldub [ %fp + -121 ], %g1 <== NOT EXECUTED
40013ea8: 84 08 60 0f and %g1, 0xf, %g2 <== NOT EXECUTED
40013eac: 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);
40013eb0: c4 0f bf 91 ldub [ %fp + -111 ], %g2
40013eb4: c6 0f bf 92 ldub [ %fp + -110 ], %g3
40013eb8: 85 28 a0 08 sll %g2, 8, %g2
40013ebc: 84 10 80 03 or %g2, %g3, %g2
40013ec0: c4 36 20 40 sth %g2, [ %i0 + 0x40 ]
if( vol->info_sec == 0 )
40013ec4: 85 28 a0 10 sll %g2, 0x10, %g2
40013ec8: 93 30 a0 10 srl %g2, 0x10, %o1
40013ecc: 80 a2 60 00 cmp %o1, 0
40013ed0: 02 80 00 4b be 40013ffc <fat_init_volume_info+0x6ec> <== NEVER TAKEN
40013ed4: 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,
40013ed8: 94 10 20 00 clr %o2
40013edc: 96 10 20 04 mov 4, %o3
40013ee0: 7f ff fd 7e call 400134d8 <_fat_block_read>
40013ee4: 98 07 bf a8 add %fp, -88, %o4
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
40013ee8: 80 a2 20 00 cmp %o0, 0
40013eec: 06 80 00 7d bl 400140e0 <fat_init_volume_info+0x7d0> <== NEVER TAKEN
40013ef0: c4 0f bf ab ldub [ %fp + -85 ], %g2
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
40013ef4: c6 0f bf a9 ldub [ %fp + -87 ], %g3
40013ef8: fa 0f bf aa ldub [ %fp + -86 ], %i5
40013efc: c8 0f bf a8 ldub [ %fp + -88 ], %g4
40013f00: 85 28 a0 18 sll %g2, 0x18, %g2
40013f04: 87 28 e0 08 sll %g3, 8, %g3
40013f08: bb 2f 60 10 sll %i5, 0x10, %i5
40013f0c: 86 10 c0 1d or %g3, %i5, %g3
40013f10: 86 10 c0 04 or %g3, %g4, %g3
40013f14: 86 10 c0 02 or %g3, %g2, %g3
40013f18: 05 10 58 54 sethi %hi(0x41615000), %g2
40013f1c: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x1215252>
40013f20: 80 a0 c0 02 cmp %g3, %g2
40013f24: 12 80 00 34 bne 40013ff4 <fat_init_volume_info+0x6e4> <== NEVER TAKEN
40013f28: 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,
40013f2c: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1
40013f30: 94 10 21 e4 mov 0x1e4, %o2
40013f34: 96 10 20 0c mov 0xc, %o3
40013f38: 7f ff fd 68 call 400134d8 <_fat_block_read>
40013f3c: 98 07 bf a8 add %fp, -88, %o4
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
40013f40: 80 a2 20 00 cmp %o0, 0
40013f44: 06 80 00 65 bl 400140d8 <fat_init_volume_info+0x7c8> <== NEVER TAKEN
40013f48: 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);
40013f4c: f2 0f bf ae ldub [ %fp + -82 ], %i1
40013f50: f4 0f bf ac ldub [ %fp + -84 ], %i2
40013f54: 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);
40013f58: f8 0f bf b1 ldub [ %fp + -79 ], %i4
40013f5c: c4 0f bf b2 ldub [ %fp + -78 ], %g2
40013f60: fa 0f bf b0 ldub [ %fp + -80 ], %i5
40013f64: 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);
40013f68: 87 28 e0 08 sll %g3, 8, %g3
40013f6c: b3 2e 60 10 sll %i1, 0x10, %i1
40013f70: b7 2e e0 18 sll %i3, 0x18, %i3
40013f74: 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);
40013f78: 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);
40013f7c: 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);
40013f80: 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);
40013f84: 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);
40013f88: 84 17 00 02 or %i4, %g2, %g2
40013f8c: 89 29 20 18 sll %g4, 0x18, %g4
40013f90: 84 10 80 1d or %g2, %i5, %g2
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
40013f94: 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);
40013f98: 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;
40013f9c: c6 26 20 44 st %g3, [ %i0 + 0x44 ]
vol->next_cl_in_fs_info =
40013fa0: 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;
40013fa4: 10 bf ff 35 b 40013c78 <fat_init_volume_info+0x368>
40013fa8: 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);
40013fac: c4 0f bf 94 ldub [ %fp + -108 ], %g2
40013fb0: d0 0f bf 95 ldub [ %fp + -107 ], %o0
40013fb4: 85 28 a0 10 sll %g2, 0x10, %g2
40013fb8: 91 2a 20 08 sll %o0, 8, %o0
40013fbc: c2 0f bf 93 ldub [ %fp + -109 ], %g1
40013fc0: 90 12 00 02 or %o0, %g2, %o0
40013fc4: c4 0f bf 8f ldub [ %fp + -113 ], %g2
40013fc8: 90 12 00 01 or %o0, %g1, %o0
40013fcc: ad 28 a0 18 sll %g2, 0x18, %l6
40013fd0: 90 12 00 16 or %o0, %l6, %o0
40013fd4: 10 bf ff 17 b 40013c30 <fat_init_volume_info+0x320>
40013fd8: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
40013fdc: 88 10 20 02 mov 2, %g4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
40013fe0: 84 10 a3 f8 or %g2, 0x3f8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
40013fe4: c8 2e 20 0e stb %g4, [ %i0 + 0xe ]
vol->mask = FAT_FAT16_MASK;
40013fe8: c6 26 20 10 st %g3, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT16_EOC;
40013fec: 10 bf ff 1d b 40013c60 <fat_init_volume_info+0x350>
40013ff0: 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);
40013ff4: 7f ff fc 94 call 40013244 <fat_buf_release> <== NOT EXECUTED
40013ff8: 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);
40013ffc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40014000: 7f ff c2 c9 call 40004b24 <close> <== NOT EXECUTED
40014004: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40014008: 40 00 20 e2 call 4001c390 <__errno> <== NOT EXECUTED
4001400c: 01 00 00 00 nop <== NOT EXECUTED
40014010: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40014014: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014018: 81 c7 e0 08 ret <== NOT EXECUTED
4001401c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = fstat(vol->fd, &stat_buf);
if (rc != 0)
{
close(vol->fd);
40014020: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40014024: 7f ff c2 c0 call 40004b24 <close> <== NOT EXECUTED
40014028: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
4001402c: 40 00 20 d9 call 4001c390 <__errno> <== NOT EXECUTED
40014030: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40014034: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
40014038: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001403c: 81 c7 e0 08 ret <== NOT EXECUTED
40014040: 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;
40014044: 10 bf ff 9b b 40013eb0 <fat_init_volume_info+0x5a0>
40014048: 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;
4001404c: 10 bf fe a3 b 40013ad8 <fat_init_volume_info+0x1c8> <== NOT EXECUTED
40014050: 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;
40014054: 10 bf fe b4 b 40013b24 <fat_init_volume_info+0x214>
40014058: 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);
4001405c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40014060: 7f ff c2 b1 call 40004b24 <close> <== NOT EXECUTED
40014064: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
40014068: 40 00 20 ca call 4001c390 <__errno> <== NOT EXECUTED
4001406c: 01 00 00 00 nop <== NOT EXECUTED
40014070: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40014074: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014078: 81 c7 e0 08 ret <== NOT EXECUTED
4001407c: 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);
40014080: 7f ff c2 a9 call 40004b24 <close> <== NOT EXECUTED
40014084: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40014088: 7f ff c2 c9 call 40004bac <free> <== NOT EXECUTED
4001408c: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40014090: 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);
40014094: 7f ff c2 c6 call 40004bac <free> <== NOT EXECUTED
40014098: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4001409c: 40 00 20 bd call 4001c390 <__errno> <== NOT EXECUTED
400140a0: 01 00 00 00 nop <== NOT EXECUTED
400140a4: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
400140a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400140ac: 81 c7 e0 08 ret <== NOT EXECUTED
400140b0: 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);
400140b4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
400140b8: 7f ff c2 9b call 40004b24 <close> <== NOT EXECUTED
400140bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
400140c0: 40 00 20 b4 call 4001c390 <__errno> <== NOT EXECUTED
400140c4: 01 00 00 00 nop <== NOT EXECUTED
400140c8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
400140cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400140d0: 81 c7 e0 08 ret <== NOT EXECUTED
400140d4: 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);
400140d8: 7f ff fc 5b call 40013244 <fat_buf_release> <== NOT EXECUTED
400140dc: 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);
400140e0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
400140e4: 7f ff c2 90 call 40004b24 <close> <== NOT EXECUTED
400140e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400140ec: 81 c7 e0 08 ret <== NOT EXECUTED
400140f0: 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);
400140f4: 7f ff c2 8c call 40004b24 <close> <== NOT EXECUTED
400140f8: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
400140fc: 7f ff c2 ac call 40004bac <free> <== NOT EXECUTED
40014100: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40014104: 7f ff c2 aa call 40004bac <free> <== NOT EXECUTED
40014108: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
4001410c: 10 bf ff e2 b 40014094 <fat_init_volume_info+0x784> <== NOT EXECUTED
40014110: 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);
40014114: 7f ff c2 84 call 40004b24 <close> <== NOT EXECUTED
40014118: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
4001411c: 10 bf ff de b 40014094 <fat_init_volume_info+0x784> <== NOT EXECUTED
40014120: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
4001a6f4 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
4001a6f4: 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;
4001a6f8: e6 06 20 38 ld [ %i0 + 0x38 ], %l3
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
4001a6fc: 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;
4001a700: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
4001a704: 80 a6 a0 00 cmp %i2, 0
4001a708: 02 80 00 49 be 4001a82c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001a70c: a4 10 20 00 clr %l2
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
4001a710: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
4001a714: 80 a4 3f ff cmp %l0, -1
4001a718: 22 80 00 02 be,a 4001a720 <fat_scan_fat_for_free_clusters+0x2c>
4001a71c: 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;
4001a720: 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)
4001a724: 80 a4 e0 02 cmp %l3, 2
4001a728: 08 80 00 4e bleu 4001a860 <fat_scan_fat_for_free_clusters+0x16c><== NEVER TAKEN
4001a72c: a2 10 20 02 mov 2, %l1
4001a730: 10 80 00 1a b 4001a798 <fat_scan_fat_for_free_clusters+0xa4>
4001a734: 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);
4001a738: 90 10 00 18 mov %i0, %o0
4001a73c: 92 10 00 10 mov %l0, %o1
4001a740: 7f ff ff 03 call 4001a34c <fat_set_fat_cluster>
4001a744: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
4001a748: 80 a2 20 00 cmp %o0, 0
4001a74c: 32 80 00 38 bne,a 4001a82c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001a750: 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)
4001a754: 80 a7 60 00 cmp %i5, 0
4001a758: 32 80 00 37 bne,a 4001a834 <fat_scan_fat_for_free_clusters+0x140>
4001a75c: d6 16 20 06 lduh [ %i0 + 6 ], %o3
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
4001a760: c2 06 c0 00 ld [ %i3 ], %g1
4001a764: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
4001a768: 80 a6 80 01 cmp %i2, %g1
4001a76c: 02 80 00 53 be 4001a8b8 <fat_scan_fat_for_free_clusters+0x1c4>
4001a770: c2 26 c0 00 st %g1, [ %i3 ]
4001a774: a8 10 00 10 mov %l0, %l4
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
4001a778: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
4001a77c: 80 a4 c0 10 cmp %l3, %l0
4001a780: 18 80 00 03 bgu 4001a78c <fat_scan_fat_for_free_clusters+0x98><== ALWAYS TAKEN
4001a784: a2 04 60 01 inc %l1
cl4find = 2;
4001a788: 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)
4001a78c: 80 a4 c0 11 cmp %l3, %l1
4001a790: 22 80 00 36 be,a 4001a868 <fat_scan_fat_for_free_clusters+0x174><== NEVER TAKEN
4001a794: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
4001a798: 90 10 00 18 mov %i0, %o0
4001a79c: 92 10 00 10 mov %l0, %o1
4001a7a0: 7f ff fe 67 call 4001a13c <fat_get_fat_cluster>
4001a7a4: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
4001a7a8: a4 92 20 00 orcc %o0, 0, %l2
4001a7ac: 12 80 00 3b bne 4001a898 <fat_scan_fat_for_free_clusters+0x1a4><== NEVER TAKEN
4001a7b0: 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)
4001a7b4: 80 a0 60 00 cmp %g1, 0
4001a7b8: 32 bf ff f1 bne,a 4001a77c <fat_scan_fat_for_free_clusters+0x88>
4001a7bc: 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)
4001a7c0: c2 06 c0 00 ld [ %i3 ], %g1
4001a7c4: 80 a0 60 00 cmp %g1, 0
4001a7c8: 22 bf ff dc be,a 4001a738 <fat_scan_fat_for_free_clusters+0x44>
4001a7cc: 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);
4001a7d0: 90 10 00 18 mov %i0, %o0
4001a7d4: 92 10 00 10 mov %l0, %o1
4001a7d8: 7f ff fe dd call 4001a34c <fat_set_fat_cluster>
4001a7dc: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
4001a7e0: 82 92 20 00 orcc %o0, 0, %g1
4001a7e4: 12 80 00 40 bne 4001a8e4 <fat_scan_fat_for_free_clusters+0x1f0><== NEVER TAKEN
4001a7e8: 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);
4001a7ec: 90 10 00 18 mov %i0, %o0
4001a7f0: 7f ff fe d7 call 4001a34c <fat_set_fat_cluster>
4001a7f4: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
4001a7f8: a8 92 20 00 orcc %o0, 0, %l4
4001a7fc: 02 bf ff d7 be 4001a758 <fat_scan_fat_for_free_clusters+0x64><== ALWAYS TAKEN
4001a800: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
4001a804: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001a808: 7f ff ff 83 call 4001a614 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001a80c: 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);
4001a810: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a814: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001a818: 7f ff fe cd call 4001a34c <fat_set_fat_cluster> <== NOT EXECUTED
4001a81c: 94 10 20 00 clr %o2 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
4001a820: 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);
4001a824: 7f ff e2 88 call 40013244 <fat_buf_release> <== NOT EXECUTED
4001a828: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
4001a82c: 81 c7 e0 08 ret
4001a830: 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);
4001a834: 90 10 00 18 mov %i0, %o0
4001a838: 92 10 00 10 mov %l0, %o1
4001a83c: 94 10 20 00 clr %o2
4001a840: 7f ff e3 72 call 40013608 <fat_cluster_set>
4001a844: 98 10 20 00 clr %o4
if (fs_info->vol.bpc != bytes_written)
4001a848: c2 16 20 06 lduh [ %i0 + 6 ], %g1
4001a84c: 80 a0 40 08 cmp %g1, %o0
4001a850: 22 bf ff c5 be,a 4001a764 <fat_scan_fat_for_free_clusters+0x70><== ALWAYS TAKEN
4001a854: c2 06 c0 00 ld [ %i3 ], %g1
{
rc = -1;
4001a858: 10 bf ff eb b 4001a804 <fat_scan_fat_for_free_clusters+0x110><== NOT EXECUTED
4001a85c: 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)
4001a860: 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)
4001a864: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
4001a868: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4001a86c: 02 80 00 05 be 4001a880 <fat_scan_fat_for_free_clusters+0x18c><== NOT EXECUTED
4001a870: e8 26 20 4c st %l4, [ %i0 + 0x4c ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
4001a874: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4001a878: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4001a87c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
4001a880: e8 27 00 00 st %l4, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001a884: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a888: 7f ff e2 6f call 40013244 <fat_buf_release> <== NOT EXECUTED
4001a88c: 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;
}
4001a890: 81 c7 e0 08 ret <== NOT EXECUTED
4001a894: 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)
4001a898: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
4001a89c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001a8a0: 02 bf ff e3 be 4001a82c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
4001a8a4: 01 00 00 00 nop <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
4001a8a8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001a8ac: 7f ff ff 5a call 4001a614 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001a8b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a8b4: 30 bf ff de b,a 4001a82c <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)
4001a8b8: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
4001a8bc: 80 a0 7f ff cmp %g1, -1
4001a8c0: 02 80 00 05 be 4001a8d4 <fat_scan_fat_for_free_clusters+0x1e0><== ALWAYS TAKEN
4001a8c4: e0 26 20 4c st %l0, [ %i0 + 0x4c ]
fs_info->vol.free_cls -= (*cls_added);
4001a8c8: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4001a8cc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4001a8d0: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
4001a8d4: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
4001a8d8: 7f ff e2 5b call 40013244 <fat_buf_release>
4001a8dc: 90 10 00 18 mov %i0, %o0
4001a8e0: 30 bf ff d3 b,a 4001a82c <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));
4001a8e4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001a8e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001a8ec: 7f ff ff 4a call 4001a614 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001a8f0: a4 10 00 01 mov %g1, %l2 <== NOT EXECUTED
4001a8f4: 30 bf ff ce b,a 4001a82c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
40013558 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
40013558: 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)
4001355c: 80 a6 e0 00 cmp %i3, 0
40013560: 02 80 00 28 be 40013600 <fat_sector_write+0xa8> <== NEVER TAKEN
40013564: a0 10 20 00 clr %l0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
40013568: 10 80 00 12 b 400135b0 <fat_sector_write+0x58>
4001356c: 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);
40013570: 96 07 bf fc add %fp, -4, %o3
40013574: 7f ff ff ab call 40013420 <fat_buf_access>
40013578: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4001357c: 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)
40013580: 80 a2 20 00 cmp %o0, 0
40013584: 12 80 00 1e bne 400135fc <fat_sector_write+0xa4> <== NEVER TAKEN
40013588: 94 10 00 1d mov %i5, %o2
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4001358c: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
40013590: 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);
40013594: 40 00 26 24 call 4001ce24 <memcpy>
40013598: 90 02 00 1a add %o0, %i2, %o0
4001359c: e2 2e 20 88 stb %l1, [ %i0 + 0x88 ]
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
sec_num++;
400135a0: 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)
400135a4: b6 a6 c0 1d subcc %i3, %i5, %i3
400135a8: 02 80 00 16 be 40013600 <fat_sector_write+0xa8> <== ALWAYS TAKEN
400135ac: b4 10 20 00 clr %i2
{
c = MIN(count, (fs_info->vol.bps - ofs));
400135b0: fa 16 00 00 lduh [ %i0 ], %i5
400135b4: ba 27 40 1a sub %i5, %i2, %i5
400135b8: 80 a7 40 1b cmp %i5, %i3
400135bc: 08 80 00 03 bleu 400135c8 <fat_sector_write+0x70>
400135c0: 92 10 00 19 mov %i1, %o1
400135c4: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
400135c8: c2 16 20 0a lduh [ %i0 + 0xa ], %g1
400135cc: 80 a0 40 1d cmp %g1, %i5
400135d0: 12 bf ff e8 bne 40013570 <fat_sector_write+0x18> <== ALWAYS TAKEN
400135d4: 94 10 20 01 mov 1, %o2
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
400135d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400135dc: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED
400135e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400135e4: 7f ff ff 8f call 40013420 <fat_buf_access> <== NOT EXECUTED
400135e8: 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);
400135ec: 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)
400135f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400135f4: 02 bf ff e6 be 4001358c <fat_sector_write+0x34> <== NOT EXECUTED
400135f8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return -1;
400135fc: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
40013600: 81 c7 e0 08 ret
40013604: 91 e8 00 10 restore %g0, %l0, %o0
4001a34c <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
4001a34c: 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;
4001a350: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4001a354: 80 a6 60 01 cmp %i1, 1
4001a358: 08 80 00 26 bleu 4001a3f0 <fat_set_fat_cluster+0xa4> <== NEVER TAKEN
4001a35c: ba 10 00 18 mov %i0, %i5
4001a360: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001a364: 82 00 60 01 inc %g1
4001a368: 80 a6 40 01 cmp %i1, %g1
4001a36c: 18 80 00 21 bgu 4001a3f0 <fat_set_fat_cluster+0xa4> <== NEVER TAKEN
4001a370: 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) +
4001a374: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001a378: 80 88 60 01 btst 1, %g1
4001a37c: 12 80 00 23 bne 4001a408 <fat_set_fat_cluster+0xbc>
4001a380: e0 0e 20 02 ldub [ %i0 + 2 ], %l0
4001a384: 82 08 60 02 and %g1, 2, %g1
4001a388: 80 88 60 ff btst 0xff, %g1
4001a38c: 02 80 00 25 be 4001a420 <fat_set_fat_cluster+0xd4>
4001a390: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001a394: b9 2e 60 01 sll %i1, 1, %i4
4001a398: a1 37 00 10 srl %i4, %l0, %l0
4001a39c: 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);
4001a3a0: e2 17 40 00 lduh [ %i5 ], %l1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001a3a4: 90 10 00 1d mov %i5, %o0
4001a3a8: 92 10 00 10 mov %l0, %o1
4001a3ac: 94 10 20 01 mov 1, %o2
4001a3b0: 7f ff e4 1c call 40013420 <fat_buf_access>
4001a3b4: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
4001a3b8: b0 92 20 00 orcc %o0, 0, %i0
4001a3bc: 12 80 00 11 bne 4001a400 <fat_set_fat_cluster+0xb4> <== NEVER TAKEN
4001a3c0: a3 2c 60 10 sll %l1, 0x10, %l1
return rc;
switch ( fs_info->vol.type )
4001a3c4: f6 0f 60 0e ldub [ %i5 + 0xe ], %i3
4001a3c8: 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);
4001a3cc: a3 34 60 10 srl %l1, 0x10, %l1
4001a3d0: 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 )
4001a3d4: 02 80 00 17 be 4001a430 <fat_set_fat_cluster+0xe4>
4001a3d8: b8 0f 00 11 and %i4, %l1, %i4
4001a3dc: 80 a6 e0 04 cmp %i3, 4
4001a3e0: 02 80 00 3b be 4001a4cc <fat_set_fat_cluster+0x180>
4001a3e4: 80 a6 e0 01 cmp %i3, 1
4001a3e8: 02 80 00 1f be 4001a464 <fat_set_fat_cluster+0x118> <== ALWAYS TAKEN
4001a3ec: 80 8e 60 01 btst 1, %i1
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4001a3f0: 40 00 07 e8 call 4001c390 <__errno> <== NOT EXECUTED
4001a3f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a3f8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a3fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
4001a400: 81 c7 e0 08 ret <== NOT EXECUTED
4001a404: 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) +
4001a408: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001a40c: b9 36 60 01 srl %i1, 1, %i4
4001a410: b8 07 00 19 add %i4, %i1, %i4
4001a414: a1 37 00 10 srl %i4, %l0, %l0
4001a418: 10 bf ff e2 b 4001a3a0 <fat_set_fat_cluster+0x54>
4001a41c: a0 04 00 01 add %l0, %g1, %l0
4001a420: b9 2e 60 02 sll %i1, 2, %i4
4001a424: a1 37 00 10 srl %i4, %l0, %l0
4001a428: 10 bf ff de b 4001a3a0 <fat_set_fat_cluster+0x54>
4001a42c: a0 04 00 01 add %l0, %g1, %l0
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
4001a430: 83 2e a0 10 sll %i2, 0x10, %g1
4001a434: 83 30 60 18 srl %g1, 0x18, %g1
break;
}
return RC_OK;
}
4001a438: 05 00 00 3f sethi %hi(0xfc00), %g2
4001a43c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
4001a440: b4 0e 80 02 and %i2, %g2, %i2
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
4001a444: b5 2e a0 08 sll %i2, 8, %i2
4001a448: b4 16 80 01 or %i2, %g1, %i2
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
4001a44c: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a450: 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;
4001a454: 82 10 20 01 mov 1, %g1
4001a458: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
4001a45c: 81 c7 e0 08 ret
4001a460: 81 e8 00 00 restore
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
4001a464: 02 80 00 30 be 4001a524 <fat_set_fat_cluster+0x1d8>
4001a468: 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);
4001a46c: 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;
4001a470: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
4001a474: 86 08 e0 0f and %g3, 0xf, %g3
4001a478: c6 28 40 1c stb %g3, [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
4001a47c: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a480: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
4001a484: 84 10 c0 02 or %g3, %g2, %g2
4001a488: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
4001a48c: c2 17 40 00 lduh [ %i5 ], %g1
4001a490: 82 00 7f ff add %g1, -1, %g1
4001a494: 80 a0 40 1c cmp %g1, %i4
4001a498: 02 80 00 3a be 4001a580 <fat_set_fat_cluster+0x234> <== NEVER TAKEN
4001a49c: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
4001a4a0: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a4a4: b8 07 20 01 inc %i4
4001a4a8: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
4001a4ac: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a4b0: b5 2e a0 14 sll %i2, 0x14, %i2
4001a4b4: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4001a4b8: b5 36 a0 18 srl %i2, 0x18, %i2
4001a4bc: 84 10 80 1a or %g2, %i2, %g2
4001a4c0: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
4001a4c4: 81 c7 e0 08 ret
4001a4c8: 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);
4001a4cc: 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));
4001a4d0: 03 3c 00 00 sethi %hi(0xf0000000), %g1
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4001a4d4: 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));
4001a4d8: 82 2e 80 01 andn %i2, %g1, %g1
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
4001a4dc: 89 30 60 18 srl %g1, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001a4e0: b7 30 60 08 srl %g1, 8, %i3
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4001a4e4: 86 08 e0 f0 and %g3, 0xf0, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a4e8: 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;
4001a4ec: b6 0e e0 ff and %i3, 0xff, %i3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a4f0: b4 16 80 04 or %i2, %g4, %i2
4001a4f4: b7 2e e0 10 sll %i3, 0x10, %i3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001a4f8: 89 30 60 10 srl %g1, 0x10, %g4
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a4fc: 82 16 80 1b or %i2, %i3, %g1
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001a500: 88 09 20 ff and %g4, 0xff, %g4
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001a504: 89 29 20 08 sll %g4, 8, %g4
4001a508: 82 10 40 04 or %g1, %g4, %g1
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
4001a50c: 82 10 40 03 or %g1, %g3, %g1
4001a510: c2 20 80 1c st %g1, [ %g2 + %i4 ]
4001a514: 82 10 20 01 mov 1, %g1
4001a518: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
4001a51c: 81 c7 e0 08 ret
4001a520: 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;
4001a524: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) &= 0x00;
4001a528: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
4001a52c: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a530: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4001a534: 84 10 80 1a or %g2, %i2, %g2
4001a538: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
4001a53c: c2 17 40 00 lduh [ %i5 ], %g1
4001a540: 82 00 7f ff add %g1, -1, %g1
4001a544: 80 a0 40 1c cmp %g1, %i4
4001a548: 02 80 00 20 be 4001a5c8 <fat_set_fat_cluster+0x27c> <== NEVER TAKEN
4001a54c: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
4001a550: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a554: b8 07 20 01 inc %i4
4001a558: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a55c: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
4001a560: 84 08 bf f0 and %g2, -16, %g2
4001a564: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a568: c2 07 bf fc ld [ %fp + -4 ], %g1
4001a56c: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4001a570: b4 10 80 1a or %g2, %i2, %i2
4001a574: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
4001a578: 81 c7 e0 08 ret
4001a57c: 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,
4001a580: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a584: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
4001a588: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001a58c: 7f ff e3 a5 call 40013420 <fat_buf_access> <== NOT EXECUTED
4001a590: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
4001a594: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001a598: 12 bf ff 9a bne 4001a400 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
4001a59c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a5a0: 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;
4001a5a4: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a5a8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001a5ac: 87 30 e0 18 srl %g3, 0x18, %g3 <== NOT EXECUTED
4001a5b0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
4001a5b4: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
4001a5b8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
4001a5bc: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
4001a5c0: 81 c7 e0 08 ret <== NOT EXECUTED
4001a5c4: 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,
4001a5c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001a5cc: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
4001a5d0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001a5d4: 7f ff e3 93 call 40013420 <fat_buf_access> <== NOT EXECUTED
4001a5d8: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
4001a5dc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001a5e0: 12 bf ff 88 bne 4001a400 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
4001a5e4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a5e8: 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;
4001a5ec: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
4001a5f0: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
4001a5f4: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a5f8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001a5fc: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
4001a600: 84 16 80 02 or %i2, %g2, %g2 <== NOT EXECUTED
4001a604: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
4001a608: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
4001a60c: 81 c7 e0 08 ret <== NOT EXECUTED
4001a610: 81 e8 00 00 restore <== NOT EXECUTED
4001424c <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)
{
4001424c: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
40014250: 90 10 00 18 mov %i0, %o0
40014254: 7f ff ff b4 call 40014124 <fat_sync>
40014258: b8 10 00 18 mov %i0, %i4
if ( rc != RC_OK )
4001425c: b0 92 20 00 orcc %o0, 0, %i0
40014260: 32 80 00 35 bne,a 40014334 <fat_shutdown_drive+0xe8> <== NEVER TAKEN
40014264: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
40014268: 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;
4001426c: fa 07 20 6c ld [ %i4 + 0x6c ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
40014270: 10 80 00 04 b 40014280 <fat_shutdown_drive+0x34>
40014274: ba 07 40 1b add %i5, %i3, %i5
free(node);
40014278: 7f ff c2 4d call 40004bac <free>
4001427c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
40014280: 7f ff d7 3a call 40009f68 <_Chain_Get>
40014284: 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 )
40014288: 80 a2 20 00 cmp %o0, 0
4001428c: 12 bf ff fb bne 40014278 <fat_shutdown_drive+0x2c>
40014290: 01 00 00 00 nop
40014294: 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++)
40014298: 80 a6 e0 18 cmp %i3, 0x18
4001429c: 32 bf ff f5 bne,a 40014270 <fat_shutdown_drive+0x24>
400142a0: fa 07 20 6c ld [ %i4 + 0x6c ], %i5
400142a4: 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;
400142a8: fa 07 20 70 ld [ %i4 + 0x70 ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
400142ac: 10 80 00 04 b 400142bc <fat_shutdown_drive+0x70>
400142b0: ba 07 40 1b add %i5, %i3, %i5
free(node);
400142b4: 7f ff c2 3e call 40004bac <free> <== NOT EXECUTED
400142b8: 01 00 00 00 nop <== NOT EXECUTED
400142bc: 7f ff d7 2b call 40009f68 <_Chain_Get>
400142c0: 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 )
400142c4: 80 a2 20 00 cmp %o0, 0
400142c8: 12 bf ff fb bne 400142b4 <fat_shutdown_drive+0x68> <== NEVER TAKEN
400142cc: 01 00 00 00 nop
400142d0: 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++)
400142d4: 80 a6 e0 18 cmp %i3, 0x18
400142d8: 32 bf ff f5 bne,a 400142ac <fat_shutdown_drive+0x60>
400142dc: fa 07 20 70 ld [ %i4 + 0x70 ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
400142e0: 7f ff c2 33 call 40004bac <free>
400142e4: d0 07 20 6c ld [ %i4 + 0x6c ], %o0
free(fs_info->rhash);
400142e8: 7f ff c2 31 call 40004bac <free>
400142ec: d0 07 20 70 ld [ %i4 + 0x70 ], %o0
free(fs_info->uino);
400142f0: 7f ff c2 2f call 40004bac <free>
400142f4: d0 07 20 74 ld [ %i4 + 0x74 ], %o0
free(fs_info->sec_buf);
400142f8: 7f ff c2 2d call 40004bac <free>
400142fc: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
close(fs_info->vol.fd);
40014300: 7f ff c2 09 call 40004b24 <close>
40014304: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
if (rc)
40014308: 80 a6 20 00 cmp %i0, 0
4001430c: 12 80 00 04 bne 4001431c <fat_shutdown_drive+0xd0> <== NEVER TAKEN
40014310: 01 00 00 00 nop
errno = EIO;
return rc;
}
40014314: 81 c7 e0 08 ret
40014318: 81 e8 00 00 restore
free(fs_info->uino);
free(fs_info->sec_buf);
close(fs_info->vol.fd);
if (rc)
errno = EIO;
4001431c: 40 00 20 1d call 4001c390 <__errno> <== NOT EXECUTED
40014320: 01 00 00 00 nop <== NOT EXECUTED
40014324: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40014328: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
4001432c: 81 c7 e0 08 ret <== NOT EXECUTED
40014330: 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;
40014334: 10 bf ff ce b 4001426c <fat_shutdown_drive+0x20> <== NOT EXECUTED
40014338: b6 10 20 00 clr %i3 <== NOT EXECUTED
40014124 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
40014124: 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)
40014128: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001412c: 80 a0 60 04 cmp %g1, 4
40014130: 02 80 00 0c be 40014160 <fat_sync+0x3c>
40014134: 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)
40014138: 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);
4001413c: 7f ff fc 42 call 40013244 <fat_buf_release>
40014140: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
40014144: 7f ff f5 05 call 40011558 <rtems_bdbuf_syncdev>
40014148: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
4001414c: 80 a2 20 00 cmp %o0, 0
40014150: 12 80 00 3d bne 40014244 <fat_sync+0x120> <== NEVER TAKEN
40014154: 01 00 00 00 nop
rc = -1;
return rc;
}
40014158: 81 c7 e0 08 ret
4001415c: 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;
40014160: 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)
40014164: 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;
40014168: f8 06 20 4c ld [ %i0 + 0x4c ], %i4
if (free_count != fs_info->vol.free_cls_in_fs_info)
4001416c: 80 a0 40 02 cmp %g1, %g2
40014170: 02 80 00 16 be 400141c8 <fat_sync+0xa4> <== ALWAYS TAKEN
40014174: b6 10 20 00 clr %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
40014178: 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,
4001417c: 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;
40014180: 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;
40014184: 89 30 60 08 srl %g1, 8, %g4 <== NOT EXECUTED
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40014188: 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;
4001418c: 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;
40014190: 85 30 60 10 srl %g1, 0x10, %g2 <== NOT EXECUTED
byte2 = (value >> 8) & 0xff;
40014194: 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;
40014198: 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;
4001419c: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
400141a0: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
400141a4: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
400141a8: 82 10 c0 02 or %g3, %g2, %g1 <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
400141ac: 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);
400141b0: 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,
400141b4: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
400141b8: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
400141bc: 7f ff fc e7 call 40013558 <fat_sector_write> <== NOT EXECUTED
400141c0: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
400141c4: 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)
400141c8: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
400141cc: 80 a7 00 02 cmp %i4, %g2
400141d0: 02 80 00 16 be 40014228 <fat_sync+0x104> <== NEVER TAKEN
400141d4: 90 10 20 00 clr %o0
400141d8: 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,
400141dc: d2 17 60 40 lduh [ %i5 + 0x40 ], %o1
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
400141e0: 83 37 20 18 srl %i4, 0x18, %g1
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400141e4: 87 37 20 08 srl %i4, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400141e8: 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;
400141ec: 86 08 e0 ff and %g3, 0xff, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400141f0: 85 37 20 10 srl %i4, 0x10, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400141f4: 87 28 e0 10 sll %g3, 0x10, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400141f8: 84 08 a0 ff and %g2, 0xff, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400141fc: 82 10 40 03 or %g1, %g3, %g1
40014200: 85 28 a0 08 sll %g2, 8, %g2
40014204: 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;
40014208: f8 27 60 50 st %i4, [ %i5 + 0x50 ]
ret2 = fat_sector_write(fs_info,
4001420c: 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);
40014210: c2 27 bf fc st %g1, [ %fp + -4 ]
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
40014214: 94 10 21 ec mov 0x1ec, %o2
40014218: 96 10 20 04 mov 4, %o3
4001421c: 7f ff fc cf call 40013558 <fat_sector_write>
40014220: 98 07 bf fc add %fp, -4, %o4
40014224: 91 32 20 1f srl %o0, 0x1f, %o0
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
40014228: 80 8a 20 ff btst 0xff, %o0
4001422c: 12 80 00 04 bne 4001423c <fat_sync+0x118> <== NEVER TAKEN
40014230: 80 8e e0 ff btst 0xff, %i3
40014234: 22 bf ff c2 be,a 4001413c <fat_sync+0x18> <== ALWAYS TAKEN
40014238: b0 10 20 00 clr %i0
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
4001423c: 10 bf ff c0 b 4001413c <fat_sync+0x18> <== NOT EXECUTED
40014240: 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;
40014244: 81 c7 e0 08 ret <== NOT EXECUTED
40014248: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40036eb4 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
40036eb4: 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 );
40036eb8: 03 10 01 90 sethi %hi(0x40064000), %g1 <== NOT EXECUTED
40036ebc: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 40064220 <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;
40036ec0: c0 27 bf c4 clr [ %fp + -60 ] <== NOT EXECUTED
st.st_uid = 0;
40036ec4: c0 37 bf ca clrh [ %fp + -54 ] <== NOT EXECUTED
st.st_gid = 0;
rtems_libio_check_fd( fd );
40036ec8: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
40036ecc: 1a 80 00 3d bcc 40036fc0 <fchdir+0x10c> <== NOT EXECUTED
40036ed0: c0 37 bf cc clrh [ %fp + -52 ] <== NOT EXECUTED
iop = rtems_libio_iop( fd );
40036ed4: 03 10 01 a0 sethi %hi(0x40068000), %g1 <== NOT EXECUTED
40036ed8: fa 00 63 0c ld [ %g1 + 0x30c ], %i5 ! 4006830c <rtems_libio_iops><== NOT EXECUTED
40036edc: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
40036ee0: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
40036ee4: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED
40036ee8: ba 07 40 18 add %i5, %i0, %i5 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
40036eec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
40036ef0: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40036ef4: 02 80 00 33 be 40036fc0 <fchdir+0x10c> <== NOT EXECUTED
40036ef8: 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;
40036efc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40036f00: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40036f04: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40036f08: 9f c0 40 00 call %g1 <== NOT EXECUTED
40036f0c: 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 );
40036f10: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40036f14: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40036f18: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
40036f1c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40036f20: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if ( rv == 0 ) {
40036f24: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40036f28: 02 80 00 09 be 40036f4c <fchdir+0x98> <== NOT EXECUTED
40036f2c: 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;
40036f30: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40036f34: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40036f38: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
40036f3c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40036f40: 01 00 00 00 nop <== NOT EXECUTED
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
40036f44: 81 c7 e0 08 ret <== NOT EXECUTED
40036f48: 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(
40036f4c: d4 17 bf ca lduh [ %fp + -54 ], %o2 <== NOT EXECUTED
40036f50: d6 17 bf cc lduh [ %fp + -52 ], %o3 <== NOT EXECUTED
40036f54: 7f ff 5d 5e call 4000e4cc <rtems_filesystem_check_access> <== NOT EXECUTED
40036f58: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
40036f5c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40036f60: 02 80 00 0d be 40036f94 <fchdir+0xe0> <== NOT EXECUTED
40036f64: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
40036f68: 7f ff 5b b4 call 4000de38 <rtems_filesystem_location_clone><== NOT EXECUTED
40036f6c: 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;
40036f70: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40036f74: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40036f78: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
40036f7c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40036f80: 01 00 00 00 nop <== NOT EXECUTED
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
40036f84: 7f ff bd 5c call 400264f4 <rtems_filesystem_chdir> <== NOT EXECUTED
40036f88: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
40036f8c: 81 c7 e0 08 ret <== NOT EXECUTED
40036f90: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
);
if ( access_ok ) {
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
} else {
errno = EACCES;
40036f94: 40 00 11 75 call 4003b568 <__errno> <== NOT EXECUTED
40036f98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40036f9c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
40036fa0: 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;
40036fa4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40036fa8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40036fac: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
40036fb0: 9f c0 40 00 call %g1 <== NOT EXECUTED
40036fb4: 01 00 00 00 nop <== NOT EXECUTED
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
40036fb8: 81 c7 e0 08 ret <== NOT EXECUTED
40036fbc: 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 );
40036fc0: 40 00 11 6a call 4003b568 <__errno> <== NOT EXECUTED
40036fc4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40036fc8: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
40036fcc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40036fd0: 81 c7 e0 08 ret <== NOT EXECUTED
40036fd4: 81 e8 00 00 restore <== NOT EXECUTED
40036fd8: 40 03 71 40 call 401134d8 <__end+0xaa2c8> <== NOT EXECUTED
40036fdc: 40 03 71 34 call 401134ac <__end+0xaa29c> <== NOT EXECUTED
40036fe0: 40 03 71 14 call 40113430 <__end+0xaa220> <== NOT EXECUTED
40036fe4: 40 03 70 f4 call 401133b4 <__end+0xaa1a4> <== NOT EXECUTED
40036fe8: 40 03 70 a0 call 40113268 <__end+0xaa058> <== NOT EXECUTED
40036fec: 40 03 70 88 call 4011320c <__end+0xa9ffc> <== NOT EXECUTED
40036ff0: 40 03 70 88 call 40113210 <__end+0xaa000> <== NOT EXECUTED
40036ff4: 40 03 70 88 call 40113214 <__end+0xaa004> <== NOT EXECUTED
40036ff8: 40 03 70 88 call 40113218 <__end+0xaa008> <== NOT EXECUTED
40036ffc: 40 03 70 88 call 4011321c <__end+0xaa00c> <== NOT EXECUTED
40026a3c <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
40026a3c: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40026a40: 03 10 01 90 sethi %hi(0x40064000), %g1
40026a44: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 40064220 <rtems_libio_number_iops>
40026a48: 80 a6 00 01 cmp %i0, %g1
40026a4c: 1a 80 00 28 bcc 40026aec <fchmod+0xb0>
40026a50: 03 10 01 a0 sethi %hi(0x40068000), %g1
iop = rtems_libio_iop( fd );
40026a54: fa 00 63 0c ld [ %g1 + 0x30c ], %i5 ! 4006830c <rtems_libio_iops>
40026a58: 83 2e 20 03 sll %i0, 3, %g1
40026a5c: b1 2e 20 06 sll %i0, 6, %i0
40026a60: b0 26 00 01 sub %i0, %g1, %i0
40026a64: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40026a68: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40026a6c: 80 88 61 00 btst 0x100, %g1
40026a70: 02 80 00 1f be 40026aec <fchmod+0xb0>
40026a74: 01 00 00 00 nop
if (iop->pathinfo.mt_entry->writeable) {
40026a78: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
40026a7c: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
40026a80: 80 a0 60 00 cmp %g1, 0
40026a84: 02 80 00 14 be 40026ad4 <fchmod+0x98> <== NEVER TAKEN
40026a88: 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 );
40026a8c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40026a90: c2 00 40 00 ld [ %g1 ], %g1
40026a94: 9f c0 40 00 call %g1
40026a98: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
40026a9c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40026aa0: 90 07 60 14 add %i5, 0x14, %o0
40026aa4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40026aa8: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40026aac: 9f c0 40 00 call %g1
40026ab0: 92 10 00 19 mov %i1, %o1
40026ab4: 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;
40026ab8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40026abc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40026ac0: c2 00 60 04 ld [ %g1 + 4 ], %g1
40026ac4: 9f c0 40 00 call %g1
40026ac8: 01 00 00 00 nop
40026acc: 81 c7 e0 08 ret
40026ad0: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
40026ad4: 40 00 52 a5 call 4003b568 <__errno> <== NOT EXECUTED
40026ad8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40026adc: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
40026ae0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40026ae4: 81 c7 e0 08 ret <== NOT EXECUTED
40026ae8: 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);
40026aec: 40 00 52 9f call 4003b568 <__errno>
40026af0: b0 10 3f ff mov -1, %i0
40026af4: 82 10 20 09 mov 9, %g1
40026af8: c2 22 00 00 st %g1, [ %o0 ]
40026afc: 81 c7 e0 08 ret
40026b00: 81 e8 00 00 restore
40026b04 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
40026b04: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40026b08: 03 10 01 90 sethi %hi(0x40064000), %g1
40026b0c: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 40064220 <rtems_libio_number_iops>
40026b10: 80 a6 00 01 cmp %i0, %g1
40026b14: 1a 80 00 29 bcc 40026bb8 <fchown+0xb4>
40026b18: 03 10 01 a0 sethi %hi(0x40068000), %g1
iop = rtems_libio_iop( fd );
40026b1c: fa 00 63 0c ld [ %g1 + 0x30c ], %i5 ! 4006830c <rtems_libio_iops>
40026b20: 83 2e 20 03 sll %i0, 3, %g1
40026b24: b1 2e 20 06 sll %i0, 6, %i0
40026b28: b0 26 00 01 sub %i0, %g1, %i0
40026b2c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40026b30: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40026b34: 80 88 61 00 btst 0x100, %g1
40026b38: 02 80 00 20 be 40026bb8 <fchown+0xb4>
40026b3c: 01 00 00 00 nop
if (iop->pathinfo.mt_entry->writeable) {
40026b40: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
40026b44: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
40026b48: 80 a0 60 00 cmp %g1, 0
40026b4c: 02 80 00 15 be 40026ba0 <fchown+0x9c> <== NEVER TAKEN
40026b50: 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 );
40026b54: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40026b58: c2 00 40 00 ld [ %g1 ], %g1
40026b5c: 9f c0 40 00 call %g1
40026b60: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
40026b64: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40026b68: 90 07 60 14 add %i5, 0x14, %o0
40026b6c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40026b70: 92 10 00 19 mov %i1, %o1
40026b74: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40026b78: 9f c0 40 00 call %g1
40026b7c: 94 10 00 1a mov %i2, %o2
40026b80: 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;
40026b84: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40026b88: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40026b8c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40026b90: 9f c0 40 00 call %g1
40026b94: 01 00 00 00 nop
40026b98: 81 c7 e0 08 ret
40026b9c: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
40026ba0: 40 00 52 72 call 4003b568 <__errno> <== NOT EXECUTED
40026ba4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40026ba8: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
40026bac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40026bb0: 81 c7 e0 08 ret <== NOT EXECUTED
40026bb4: 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);
40026bb8: 40 00 52 6c call 4003b568 <__errno>
40026bbc: b0 10 3f ff mov -1, %i0
40026bc0: 82 10 20 09 mov 9, %g1
40026bc4: c2 22 00 00 st %g1, [ %o0 ]
40026bc8: 81 c7 e0 08 ret
40026bcc: 81 e8 00 00 restore
40032f8c <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
40032f8c: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
40032f90: 03 10 00 e4 sethi %hi(0x40039000), %g1
40032f94: c4 00 61 ac ld [ %g1 + 0x1ac ], %g2 ! 400391ac <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
40032f98: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40032f9c: 82 07 a0 4c add %fp, 0x4c, %g1
40032fa0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40032fa4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40032fa8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
40032fac: 80 a6 00 02 cmp %i0, %g2
40032fb0: 1a 80 00 7c bcc 400331a0 <fcntl+0x214>
40032fb4: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
40032fb8: 39 10 01 27 sethi %hi(0x40049c00), %i4
40032fbc: fa 07 20 90 ld [ %i4 + 0x90 ], %i5 ! 40049c90 <rtems_libio_iops>
40032fc0: 85 2e 20 03 sll %i0, 3, %g2
40032fc4: b1 2e 20 06 sll %i0, 6, %i0
40032fc8: b0 26 00 02 sub %i0, %g2, %i0
40032fcc: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40032fd0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
40032fd4: 80 8a 21 00 btst 0x100, %o0
40032fd8: 02 80 00 72 be 400331a0 <fcntl+0x214>
40032fdc: 80 a6 60 09 cmp %i1, 9
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
40032fe0: 08 80 00 08 bleu 40033000 <fcntl+0x74>
40032fe4: 85 2e 60 02 sll %i1, 2, %g2
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
40032fe8: 7f ff be 54 call 40022938 <__errno>
40032fec: b0 10 3f ff mov -1, %i0
40032ff0: 82 10 20 16 mov 0x16, %g1
40032ff4: c2 22 00 00 st %g1, [ %o0 ]
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
40032ff8: 81 c7 e0 08 ret
40032ffc: 81 e8 00 00 restore
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
40033000: 07 10 00 cb sethi %hi(0x40032c00), %g3
40033004: 86 10 e3 64 or %g3, 0x364, %g3 ! 40032f64 <_calloc_r+0x14>
40033008: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
4003300c: 81 c0 80 00 jmp %g2
40033010: 01 00 00 00 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
40033014: 7f ff be 49 call 40022938 <__errno>
40033018: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
4003301c: 82 10 20 86 mov 0x86, %g1
40033020: c2 22 00 00 st %g1, [ %o0 ]
40033024: 81 c7 e0 08 ret
40033028: 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 ) );
4003302c: d0 00 40 00 ld [ %g1 ], %o0
40033030: 7f ff 54 9d call 400082a4 <rtems_libio_fcntl_flags>
40033034: 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);
40033038: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4003303c: 90 0a 22 01 and %o0, 0x201, %o0
40033040: 82 08 7d fe and %g1, -514, %g1
40033044: 82 12 00 01 or %o0, %g1, %g1
40033048: 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 );
4003304c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40033050: 90 10 00 1d mov %i5, %o0
40033054: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
40033058: 9f c0 40 00 call %g1
4003305c: 92 10 00 19 mov %i1, %o1
if (err) {
40033060: ba 92 20 00 orcc %o0, 0, %i5
40033064: 02 80 00 53 be 400331b0 <fcntl+0x224> <== ALWAYS TAKEN
40033068: 01 00 00 00 nop
errno = err;
4003306c: 7f ff be 33 call 40022938 <__errno> <== NOT EXECUTED
40033070: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40033074: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
40033078: 81 c7 e0 08 ret <== NOT EXECUTED
4003307c: 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 );
40033080: 7f ff 54 96 call 400082d8 <rtems_libio_to_fcntl_flags>
40033084: 01 00 00 00 nop
40033088: 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) {
4003308c: 80 a6 20 00 cmp %i0, 0
40033090: 36 bf ff f0 bge,a 40033050 <fcntl+0xc4> <== ALWAYS TAKEN
40033094: 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;
}
40033098: 81 c7 e0 08 ret <== NOT EXECUTED
4003309c: 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 ) )
400330a0: c2 00 40 00 ld [ %g1 ], %g1
400330a4: 80 a0 60 00 cmp %g1, 0
400330a8: 22 80 00 3b be,a 40033194 <fcntl+0x208>
400330ac: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
400330b0: 90 12 28 00 or %o0, 0x800, %o0
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
400330b4: 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;
400330b8: 10 bf ff e5 b 4003304c <fcntl+0xc0>
400330bc: 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);
400330c0: b1 32 20 0b srl %o0, 0xb, %i0
400330c4: 10 bf ff e2 b 4003304c <fcntl+0xc0>
400330c8: 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();
400330cc: 7f ff 54 9a call 40008334 <rtems_libio_allocate>
400330d0: 01 00 00 00 nop
if (diop != NULL) {
400330d4: b6 92 20 00 orcc %o0, 0, %i3
400330d8: 02 bf ff c8 be 40032ff8 <fcntl+0x6c>
400330dc: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
400330e0: 7f ff 54 7e call 400082d8 <rtems_libio_to_fcntl_flags>
400330e4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
400330e8: 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;
400330ec: b4 0a 3d ff and %o0, -513, %i2
diop->flags |= rtems_libio_fcntl_flags( oflag );
400330f0: 7f ff 54 6d call 400082a4 <rtems_libio_fcntl_flags>
400330f4: 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;
400330f8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400330fc: b0 12 00 18 or %o0, %i0, %i0
(*mt_entry->ops->lock_h)( mt_entry );
40033100: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40033104: 90 10 00 01 mov %g1, %o0
40033108: c2 00 80 00 ld [ %g2 ], %g1
4003310c: 9f c0 40 00 call %g1
40033110: f0 26 e0 10 st %i0, [ %i3 + 0x10 ]
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40033114: 92 07 60 14 add %i5, 0x14, %o1
40033118: 7f ff 91 ac call 400177c8 <rtems_filesystem_location_clone>
4003311c: 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;
40033120: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40033124: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40033128: c2 00 60 04 ld [ %g1 + 4 ], %g1
4003312c: 9f c0 40 00 call %g1
40033130: 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 );
40033134: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
40033138: 90 10 00 1b mov %i3, %o0
4003313c: c2 00 40 00 ld [ %g1 ], %g1
40033140: 92 10 20 00 clr %o1
40033144: 94 10 00 1a mov %i2, %o2
40033148: 9f c0 40 00 call %g1
4003314c: 96 10 20 00 clr %o3
if ( rv == 0 ) {
40033150: b0 92 20 00 orcc %o0, 0, %i0
40033154: 12 80 00 19 bne 400331b8 <fcntl+0x22c> <== NEVER TAKEN
40033158: c2 07 20 90 ld [ %i4 + 0x90 ], %g1
rv = diop - rtems_libio_iops;
4003315c: b6 26 c0 01 sub %i3, %g1, %i3
40033160: b7 3e e0 03 sra %i3, 3, %i3
40033164: 85 2e e0 03 sll %i3, 3, %g2
40033168: 83 2e e0 06 sll %i3, 6, %g1
4003316c: 82 00 80 01 add %g2, %g1, %g1
40033170: 85 28 60 06 sll %g1, 6, %g2
40033174: 82 00 40 02 add %g1, %g2, %g1
40033178: 82 00 40 1b add %g1, %i3, %g1
4003317c: 85 28 60 0f sll %g1, 0xf, %g2
40033180: 82 00 40 02 add %g1, %g2, %g1
40033184: 83 28 60 03 sll %g1, 3, %g1
40033188: b6 00 40 1b add %g1, %i3, %i3
4003318c: 10 bf ff c0 b 4003308c <fcntl+0x100>
40033190: b0 20 00 1b neg %i3, %i0
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
40033194: 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;
40033198: 10 bf ff ad b 4003304c <fcntl+0xc0>
4003319c: 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);
400331a0: 7f ff bd e6 call 40022938 <__errno>
400331a4: b0 10 3f ff mov -1, %i0
400331a8: 82 10 20 09 mov 9, %g1
400331ac: c2 22 00 00 st %g1, [ %o0 ]
400331b0: 81 c7 e0 08 ret
400331b4: 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 );
400331b8: 7f ff 54 75 call 4000838c <rtems_libio_free> <== NOT EXECUTED
400331bc: 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) {
400331c0: 10 bf ff b4 b 40033090 <fcntl+0x104> <== NOT EXECUTED
400331c4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40003a0c <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
40003a0c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40003a10: 03 10 00 5b sethi %hi(0x40016c00), %g1
40003a14: c2 00 62 c4 ld [ %g1 + 0x2c4 ], %g1 ! 40016ec4 <rtems_libio_number_iops>
40003a18: 80 a6 00 01 cmp %i0, %g1
40003a1c: 1a 80 00 13 bcc 40003a68 <fdatasync+0x5c>
40003a20: 03 10 00 5e sethi %hi(0x40017800), %g1
iop = rtems_libio_iop( fd );
40003a24: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 ! 4001781c <rtems_libio_iops>
40003a28: 83 2e 20 03 sll %i0, 3, %g1
40003a2c: b1 2e 20 06 sll %i0, 6, %i0
40003a30: b0 26 00 01 sub %i0, %g1, %i0
40003a34: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open(iop);
40003a38: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40003a3c: 80 88 61 00 btst 0x100, %g1
40003a40: 02 80 00 0a be 40003a68 <fdatasync+0x5c> <== NEVER TAKEN
40003a44: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40003a48: 02 80 00 08 be 40003a68 <fdatasync+0x5c>
40003a4c: 01 00 00 00 nop
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
40003a50: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
40003a54: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40003a58: 9f c0 40 00 call %g1
40003a5c: 01 00 00 00 nop
}
40003a60: 81 c7 e0 08 ret
40003a64: 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 );
40003a68: 40 00 32 55 call 400103bc <__errno>
40003a6c: b0 10 3f ff mov -1, %i0
40003a70: 82 10 20 09 mov 9, %g1
40003a74: c2 22 00 00 st %g1, [ %o0 ]
40003a78: 81 c7 e0 08 ret
40003a7c: 81 e8 00 00 restore
4000db00 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000db00: 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) {
4000db04: 3b 10 00 8e sethi %hi(0x40023800), %i5
4000db08: d0 07 60 98 ld [ %i5 + 0x98 ], %o0 ! 40023898 <pipe_semaphore>
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000db0c: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4000db10: 80 a2 20 00 cmp %o0, 0
4000db14: 02 80 00 18 be 4000db74 <fifo_open+0x74>
4000db18: b8 17 60 98 or %i5, 0x98, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000db1c: 92 10 20 00 clr %o1
4000db20: 7f ff eb d9 call 40008a84 <rtems_semaphore_obtain>
4000db24: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
4000db28: 80 a2 20 00 cmp %o0, 0
4000db2c: 12 80 00 7a bne 4000dd14 <fifo_open+0x214> <== NEVER TAKEN
4000db30: 01 00 00 00 nop
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
4000db34: f8 06 c0 00 ld [ %i3 ], %i4
if (pipe == NULL) {
4000db38: 80 a7 20 00 cmp %i4, 0
4000db3c: 02 80 00 1b be 4000dba8 <fifo_open+0xa8>
4000db40: 01 00 00 00 nop
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4000db44: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
4000db48: 92 10 20 00 clr %o1
4000db4c: 7f ff eb ce call 40008a84 <rtems_semaphore_obtain>
4000db50: 94 10 20 00 clr %o2
4000db54: 80 a2 20 00 cmp %o0, 0
4000db58: 02 80 00 8c be 4000dd88 <fifo_open+0x288> <== ALWAYS TAKEN
4000db5c: c2 06 c0 00 ld [ %i3 ], %g1
err = -EINTR;
if (*pipep == NULL) {
4000db60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000db64: 22 80 00 6e be,a 4000dd1c <fifo_open+0x21c> <== NOT EXECUTED
4000db68: d0 07 20 2c ld [ %i4 + 0x2c ], %o0 <== NOT EXECUTED
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000db6c: 10 80 00 76 b 4000dd44 <fifo_open+0x244> <== NOT EXECUTED
4000db70: 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 );
4000db74: 35 10 00 8e sethi %hi(0x40023800), %i2
4000db78: d0 06 a2 18 ld [ %i2 + 0x218 ], %o0 ! 40023a18 <rtems_libio_semaphore>
4000db7c: 92 10 20 00 clr %o1
4000db80: 7f ff eb c1 call 40008a84 <rtems_semaphore_obtain>
4000db84: 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) {
4000db88: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
4000db8c: 80 a0 60 00 cmp %g1, 0
4000db90: 02 80 00 55 be 4000dce4 <fifo_open+0x1e4> <== ALWAYS TAKEN
4000db94: 98 10 00 1c mov %i4, %o4
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000db98: 7f ff ec 0a call 40008bc0 <rtems_semaphore_release> <== NOT EXECUTED
4000db9c: d0 06 a2 18 ld [ %i2 + 0x218 ], %o0 <== NOT EXECUTED
4000dba0: 10 bf ff df b 4000db1c <fifo_open+0x1c> <== NOT EXECUTED
4000dba4: d0 07 60 98 ld [ %i5 + 0x98 ], %o0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4000dba8: 7f ff da 71 call 4000456c <malloc>
4000dbac: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
4000dbb0: b8 92 20 00 orcc %o0, 0, %i4
4000dbb4: 02 80 00 73 be 4000dd80 <fifo_open+0x280> <== NEVER TAKEN
4000dbb8: 82 10 22 00 mov 0x200, %g1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4000dbbc: c0 27 00 00 clr [ %i4 ]
4000dbc0: c0 27 20 08 clr [ %i4 + 8 ]
4000dbc4: c0 27 20 0c clr [ %i4 + 0xc ]
4000dbc8: c0 27 20 10 clr [ %i4 + 0x10 ]
4000dbcc: c0 27 20 14 clr [ %i4 + 0x14 ]
4000dbd0: c0 27 20 18 clr [ %i4 + 0x18 ]
4000dbd4: c0 27 20 1c clr [ %i4 + 0x1c ]
4000dbd8: c0 27 20 20 clr [ %i4 + 0x20 ]
4000dbdc: c0 27 20 24 clr [ %i4 + 0x24 ]
4000dbe0: c0 27 20 28 clr [ %i4 + 0x28 ]
4000dbe4: c0 27 20 2c clr [ %i4 + 0x2c ]
4000dbe8: c0 27 20 30 clr [ %i4 + 0x30 ]
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
4000dbec: 90 10 22 00 mov 0x200, %o0
4000dbf0: 7f ff da 5f call 4000456c <malloc>
4000dbf4: c2 27 20 04 st %g1, [ %i4 + 4 ]
if (! pipe->Buffer)
4000dbf8: 80 a2 20 00 cmp %o0, 0
4000dbfc: 02 80 00 5f be 4000dd78 <fifo_open+0x278> <== NEVER TAKEN
4000dc00: d0 27 00 00 st %o0, [ %i4 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
4000dc04: 35 10 00 8c sethi %hi(0x40023000), %i2
4000dc08: d0 4e a1 8c ldsb [ %i2 + 0x18c ], %o0 ! 4002318c <c.7174>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4000dc0c: 31 14 12 5c sethi %hi(0x50497000), %i0
4000dc10: 82 16 22 00 or %i0, 0x200, %g1 ! 50497200 <RAM_END+0x10097200>
4000dc14: 92 10 20 00 clr %o1
4000dc18: 94 10 20 00 clr %o2
4000dc1c: 90 12 00 01 or %o0, %g1, %o0
4000dc20: 40 00 06 29 call 4000f4c4 <rtems_barrier_create>
4000dc24: 96 07 20 2c add %i4, 0x2c, %o3
4000dc28: 80 a2 20 00 cmp %o0, 0
4000dc2c: 12 80 00 51 bne 4000dd70 <fifo_open+0x270>
4000dc30: d0 4e a1 8c ldsb [ %i2 + 0x18c ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4000dc34: 03 14 12 5d sethi %hi(0x50497400), %g1
4000dc38: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000dc3c: 92 10 20 00 clr %o1
4000dc40: 94 10 20 00 clr %o2
4000dc44: 90 12 00 01 or %o0, %g1, %o0
4000dc48: 40 00 06 1f call 4000f4c4 <rtems_barrier_create>
4000dc4c: 96 07 20 30 add %i4, 0x30, %o3
4000dc50: 80 a2 20 00 cmp %o0, 0
4000dc54: 12 80 00 45 bne 4000dd68 <fifo_open+0x268>
4000dc58: d0 4e a1 8c ldsb [ %i2 + 0x18c ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4000dc5c: b0 16 23 00 or %i0, 0x300, %i0
4000dc60: 92 10 20 01 mov 1, %o1
4000dc64: 90 12 00 18 or %o0, %i0, %o0
4000dc68: 94 10 20 10 mov 0x10, %o2
4000dc6c: 96 10 20 00 clr %o3
4000dc70: 7f ff ea dd call 400087e4 <rtems_semaphore_create>
4000dc74: 98 07 20 28 add %i4, 0x28, %o4
4000dc78: 80 a2 20 00 cmp %o0, 0
4000dc7c: 12 80 00 39 bne 4000dd60 <fifo_open+0x260>
4000dc80: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
4000dc84: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
4000dc88: 21 10 00 91 sethi %hi(0x40024400), %l0
4000dc8c: 7f ff f2 85 call 4000a6a0 <_Objects_Get>
4000dc90: 90 14 20 b0 or %l0, 0xb0, %o0 ! 400244b0 <_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;
4000dc94: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000dc98: 31 04 00 00 sethi %hi(0x10000000), %i0
4000dc9c: 82 10 40 18 or %g1, %i0, %g1
_Thread_Enable_dispatch();
4000dca0: 7f ff f6 37 call 4000b57c <_Thread_Enable_dispatch>
4000dca4: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
4000dca8: d2 07 20 30 ld [ %i4 + 0x30 ], %o1
4000dcac: 94 07 bf fc add %fp, -4, %o2
4000dcb0: 7f ff f2 7c call 4000a6a0 <_Objects_Get>
4000dcb4: 90 14 20 b0 or %l0, 0xb0, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4000dcb8: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000dcbc: b0 10 40 18 or %g1, %i0, %i0
_Thread_Enable_dispatch();
4000dcc0: 7f ff f6 2f call 4000b57c <_Thread_Enable_dispatch>
4000dcc4: f0 22 20 4c st %i0, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4000dcc8: c2 4e a1 8c ldsb [ %i2 + 0x18c ], %g1
4000dccc: 80 a0 60 7a cmp %g1, 0x7a
4000dcd0: 02 80 00 21 be 4000dd54 <fifo_open+0x254>
4000dcd4: c4 0e a1 8c ldub [ %i2 + 0x18c ], %g2
4000dcd8: 84 00 a0 01 inc %g2
4000dcdc: 10 bf ff 9a b 4000db44 <fifo_open+0x44>
4000dce0: c4 2e a1 8c stb %g2, [ %i2 + 0x18c ]
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
4000dce4: 92 10 20 01 mov 1, %o1
4000dce8: 94 10 20 54 mov 0x54, %o2
4000dcec: 96 10 20 00 clr %o3
4000dcf0: 11 14 12 54 sethi %hi(0x50495000), %o0
4000dcf4: 7f ff ea bc call 400087e4 <rtems_semaphore_create>
4000dcf8: 90 12 20 45 or %o0, 0x45, %o0 ! 50495045 <RAM_END+0x10095045>
4000dcfc: b8 10 00 08 mov %o0, %i4
4000dd00: 7f ff eb b0 call 40008bc0 <rtems_semaphore_release>
4000dd04: d0 06 a2 18 ld [ %i2 + 0x218 ], %o0
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4000dd08: 80 a7 20 00 cmp %i4, 0
4000dd0c: 02 bf ff 84 be 4000db1c <fifo_open+0x1c>
4000dd10: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
err = -ENXIO;
4000dd14: 81 c7 e0 08 ret
4000dd18: 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);
4000dd1c: 40 00 06 1b call 4000f588 <rtems_barrier_delete> <== NOT EXECUTED
4000dd20: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
4000dd24: 40 00 06 19 call 4000f588 <rtems_barrier_delete> <== NOT EXECUTED
4000dd28: d0 07 20 30 ld [ %i4 + 0x30 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
4000dd2c: 7f ff eb 1f call 400089a8 <rtems_semaphore_delete> <== NOT EXECUTED
4000dd30: d0 07 20 28 ld [ %i4 + 0x28 ], %o0 <== NOT EXECUTED
free(pipe->Buffer);
4000dd34: 7f ff d8 f3 call 40004100 <free> <== NOT EXECUTED
4000dd38: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free(pipe);
4000dd3c: 7f ff d8 f1 call 40004100 <free> <== NOT EXECUTED
4000dd40: 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);
4000dd44: 7f ff eb 9f call 40008bc0 <rtems_semaphore_release>
4000dd48: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
4000dd4c: 81 c7 e0 08 ret
4000dd50: 81 e8 00 00 restore
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
c = 'a';
4000dd54: 82 10 20 61 mov 0x61, %g1
4000dd58: 10 bf ff 7b b 4000db44 <fifo_open+0x44>
4000dd5c: c2 2e a1 8c stb %g1, [ %i2 + 0x18c ]
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4000dd60: 40 00 06 0a call 4000f588 <rtems_barrier_delete>
4000dd64: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
4000dd68: 40 00 06 08 call 4000f588 <rtems_barrier_delete>
4000dd6c: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
4000dd70: 7f ff d8 e4 call 40004100 <free>
4000dd74: d0 07 00 00 ld [ %i4 ], %o0
err_buf:
free(pipe);
4000dd78: 7f ff d8 e2 call 40004100 <free>
4000dd7c: 90 10 00 1c mov %i4, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000dd80: 10 bf ff f1 b 4000dd44 <fifo_open+0x244>
4000dd84: b0 10 3f f4 mov -12, %i0
if (*pipep == NULL) {
4000dd88: 80 a0 60 00 cmp %g1, 0
4000dd8c: 22 80 00 02 be,a 4000dd94 <fifo_open+0x294>
4000dd90: f8 26 c0 00 st %i4, [ %i3 ]
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000dd94: 7f ff eb 8b call 40008bc0 <rtems_semaphore_release>
4000dd98: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4000dd9c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000dda0: 82 08 60 06 and %g1, 6, %g1
4000dda4: 80 a0 60 04 cmp %g1, 4
4000dda8: 02 80 00 0c be 4000ddd8 <fifo_open+0x2d8>
4000ddac: fa 06 c0 00 ld [ %i3 ], %i5
4000ddb0: 80 a0 60 06 cmp %g1, 6
4000ddb4: 02 80 00 58 be 4000df14 <fifo_open+0x414>
4000ddb8: 80 a0 60 02 cmp %g1, 2
4000ddbc: 22 80 00 31 be,a 4000de80 <fifo_open+0x380> <== ALWAYS TAKEN
4000ddc0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
4000ddc4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
4000ddc8: 7f ff eb 7e call 40008bc0 <rtems_semaphore_release>
4000ddcc: b0 10 20 00 clr %i0
return 0;
4000ddd0: 81 c7 e0 08 ret
4000ddd4: 81 e8 00 00 restore
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4000ddd8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4000dddc: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
if (pipe->Writers ++ == 0)
4000dde0: 86 00 60 01 add %g1, 1, %g3
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4000dde4: 84 00 a0 01 inc %g2
if (pipe->Writers ++ == 0)
4000dde8: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
4000ddec: 80 a0 60 00 cmp %g1, 0
4000ddf0: 02 80 00 68 be 4000df90 <fifo_open+0x490> <== ALWAYS TAKEN
4000ddf4: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000ddf8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
4000ddfc: 80 a0 60 00 cmp %g1, 0
4000de00: 32 bf ff f2 bne,a 4000ddc8 <fifo_open+0x2c8>
4000de04: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000de08: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000de0c: 80 88 60 01 btst 1, %g1
4000de10: 32 80 00 65 bne,a 4000dfa4 <fifo_open+0x4a4>
4000de14: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
4000de18: 10 80 00 0c b 4000de48 <fifo_open+0x348>
4000de1c: 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))
4000de20: 92 10 20 00 clr %o1
4000de24: 7f ff eb 18 call 40008a84 <rtems_semaphore_obtain>
4000de28: 94 10 20 00 clr %o2
4000de2c: 80 a2 20 00 cmp %o0, 0
4000de30: 12 80 00 0f bne 4000de6c <fifo_open+0x36c> <== NEVER TAKEN
4000de34: b0 10 3f fc mov -4, %i0
goto out_error;
} while (prevCounter == pipe->readerCounter);
4000de38: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000de3c: 80 a0 40 1c cmp %g1, %i4
4000de40: 32 bf ff e2 bne,a 4000ddc8 <fifo_open+0x2c8> <== ALWAYS TAKEN
4000de44: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4000de48: 7f ff eb 5e call 40008bc0 <rtems_semaphore_release>
4000de4c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
4000de50: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000de54: 40 00 06 0e call 4000f68c <rtems_barrier_wait>
4000de58: 92 10 20 00 clr %o1
4000de5c: 80 a2 20 00 cmp %o0, 0
4000de60: 22 bf ff f0 be,a 4000de20 <fifo_open+0x320> <== ALWAYS TAKEN
4000de64: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
4000de68: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4000de6c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000de70: 7f ff fe e5 call 4000da04 <pipe_release>
4000de74: 92 10 00 19 mov %i1, %o1
return err;
4000de78: 81 c7 e0 08 ret
4000de7c: 81 e8 00 00 restore
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4000de80: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
if (pipe->Readers ++ == 0)
4000de84: 86 00 60 01 add %g1, 1, %g3
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4000de88: 84 00 a0 01 inc %g2
if (pipe->Readers ++ == 0)
4000de8c: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
4000de90: 80 a0 60 00 cmp %g1, 0
4000de94: 02 80 00 35 be 4000df68 <fifo_open+0x468> <== ALWAYS TAKEN
4000de98: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
4000de9c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
4000dea0: 80 a0 60 00 cmp %g1, 0
4000dea4: 32 bf ff c9 bne,a 4000ddc8 <fifo_open+0x2c8>
4000dea8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
4000deac: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000deb0: 80 88 60 01 btst 1, %g1
4000deb4: 32 bf ff c5 bne,a 4000ddc8 <fifo_open+0x2c8>
4000deb8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
break;
prevCounter = pipe->writerCounter;
4000debc: 10 80 00 0c b 4000deec <fifo_open+0x3ec>
4000dec0: 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))
4000dec4: 92 10 20 00 clr %o1
4000dec8: 7f ff ea ef call 40008a84 <rtems_semaphore_obtain>
4000decc: 94 10 20 00 clr %o2
4000ded0: 80 a2 20 00 cmp %o0, 0
4000ded4: 12 bf ff e6 bne 4000de6c <fifo_open+0x36c> <== NEVER TAKEN
4000ded8: b0 10 3f fc mov -4, %i0
goto out_error;
} while (prevCounter == pipe->writerCounter);
4000dedc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000dee0: 80 a0 40 1c cmp %g1, %i4
4000dee4: 32 bf ff b9 bne,a 4000ddc8 <fifo_open+0x2c8> <== ALWAYS TAKEN
4000dee8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4000deec: 7f ff eb 35 call 40008bc0 <rtems_semaphore_release>
4000def0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
4000def4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000def8: 40 00 05 e5 call 4000f68c <rtems_barrier_wait>
4000defc: 92 10 20 00 clr %o1
4000df00: 80 a2 20 00 cmp %o0, 0
4000df04: 22 bf ff f0 be,a 4000dec4 <fifo_open+0x3c4> <== ALWAYS TAKEN
4000df08: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
4000df0c: 10 bf ff d8 b 4000de6c <fifo_open+0x36c> <== NOT EXECUTED
4000df10: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4000df14: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4000df18: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
if (pipe->Readers ++ == 0)
4000df1c: 86 00 60 01 add %g1, 1, %g3
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4000df20: 84 00 a0 01 inc %g2
if (pipe->Readers ++ == 0)
4000df24: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
4000df28: 80 a0 60 00 cmp %g1, 0
4000df2c: 02 80 00 14 be 4000df7c <fifo_open+0x47c> <== ALWAYS TAKEN
4000df30: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4000df34: 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 ++;
4000df38: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
if (pipe->Writers ++ == 0)
4000df3c: 86 00 60 01 add %g1, 1, %g3
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
4000df40: 84 00 a0 01 inc %g2
if (pipe->Writers ++ == 0)
4000df44: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
4000df48: 80 a0 60 00 cmp %g1, 0
4000df4c: 12 bf ff 9e bne 4000ddc4 <fifo_open+0x2c4> <== NEVER TAKEN
4000df50: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
PIPE_WAKEUPREADERS(pipe);
4000df54: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000df58: 40 00 05 b5 call 4000f62c <rtems_barrier_release>
4000df5c: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
4000df60: 10 bf ff 9a b 4000ddc8 <fifo_open+0x2c8>
4000df64: 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);
4000df68: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000df6c: 40 00 05 b0 call 4000f62c <rtems_barrier_release>
4000df70: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
4000df74: 10 bf ff cb b 4000dea0 <fifo_open+0x3a0>
4000df78: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
4000df7c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000df80: 40 00 05 ab call 4000f62c <rtems_barrier_release>
4000df84: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4000df88: 10 bf ff ec b 4000df38 <fifo_open+0x438>
4000df8c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
4000df90: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000df94: 40 00 05 a6 call 4000f62c <rtems_barrier_release>
4000df98: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000df9c: 10 bf ff 98 b 4000ddfc <fifo_open+0x2fc>
4000dfa0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
PIPE_UNLOCK(pipe);
4000dfa4: 7f ff eb 07 call 40008bc0 <rtems_semaphore_release>
4000dfa8: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
4000dfac: 10 bf ff b1 b 4000de70 <fifo_open+0x370>
4000dfb0: 90 10 00 1b mov %i3, %o0
40009a50 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
40009a50: 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);
40009a54: 03 10 00 54 sethi %hi(0x40015000), %g1
40009a58: c2 00 62 48 ld [ %g1 + 0x248 ], %g1 ! 40015248 <rtems_libio_number_iops>
40009a5c: 80 a6 00 01 cmp %i0, %g1
40009a60: 1a 80 00 3e bcc 40009b58 <fpathconf+0x108>
40009a64: 03 10 00 56 sethi %hi(0x40015800), %g1
iop = rtems_libio_iop(fd);
40009a68: c2 00 63 80 ld [ %g1 + 0x380 ], %g1 ! 40015b80 <rtems_libio_iops>
40009a6c: 85 2e 20 03 sll %i0, 3, %g2
40009a70: b1 2e 20 06 sll %i0, 6, %i0
40009a74: b0 26 00 02 sub %i0, %g2, %i0
40009a78: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_is_open(iop);
40009a7c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40009a80: 80 88 61 00 btst 0x100, %g1
40009a84: 02 80 00 35 be 40009b58 <fpathconf+0x108> <== NEVER TAKEN
40009a88: 80 a6 60 0b cmp %i1, 0xb
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
40009a8c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
switch ( name ) {
40009a90: 08 80 00 08 bleu 40009ab0 <fpathconf+0x60>
40009a94: 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 );
40009a98: 40 00 09 72 call 4000c060 <__errno>
40009a9c: b0 10 3f ff mov -1, %i0
40009aa0: 82 10 20 16 mov 0x16, %g1
40009aa4: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
40009aa8: 81 c7 e0 08 ret
40009aac: 81 e8 00 00 restore
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
40009ab0: b3 2e 60 02 sll %i1, 2, %i1
40009ab4: 05 10 00 26 sethi %hi(0x40009800), %g2
40009ab8: 84 10 a2 20 or %g2, 0x220, %g2 ! 40009a20 <_close_r+0x10>
40009abc: c4 00 80 19 ld [ %g2 + %i1 ], %g2
40009ac0: 81 c0 80 00 jmp %g2
40009ac4: 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;
40009ac8: f0 00 60 24 ld [ %g1 + 0x24 ], %i0
break;
40009acc: 81 c7 e0 08 ret
40009ad0: 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;
40009ad4: f0 00 60 18 ld [ %g1 + 0x18 ], %i0
break;
40009ad8: 81 c7 e0 08 ret
40009adc: 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;
40009ae0: f0 00 60 2c ld [ %g1 + 0x2c ], %i0
break;
40009ae4: 81 c7 e0 08 ret
40009ae8: 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;
40009aec: f0 00 60 20 ld [ %g1 + 0x20 ], %i0
break;
40009af0: 81 c7 e0 08 ret
40009af4: 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;
40009af8: f0 00 60 1c ld [ %g1 + 0x1c ], %i0
break;
40009afc: 81 c7 e0 08 ret
40009b00: 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;
40009b04: f0 00 60 14 ld [ %g1 + 0x14 ], %i0
break;
40009b08: 81 c7 e0 08 ret
40009b0c: 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;
40009b10: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
break;
40009b14: 81 c7 e0 08 ret
40009b18: 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;
40009b1c: f0 00 60 0c ld [ %g1 + 0xc ], %i0
break;
40009b20: 81 c7 e0 08 ret
40009b24: 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;
40009b28: f0 00 60 08 ld [ %g1 + 8 ], %i0
break;
40009b2c: 81 c7 e0 08 ret
40009b30: 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;
40009b34: f0 00 60 04 ld [ %g1 + 4 ], %i0
break;
40009b38: 81 c7 e0 08 ret
40009b3c: 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;
40009b40: f0 00 40 00 ld [ %g1 ], %i0
break;
40009b44: 81 c7 e0 08 ret
40009b48: 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;
40009b4c: f0 00 60 28 ld [ %g1 + 0x28 ], %i0
break;
40009b50: 81 c7 e0 08 ret
40009b54: 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);
40009b58: 40 00 09 42 call 4000c060 <__errno>
40009b5c: b0 10 3f ff mov -1, %i0
40009b60: 82 10 20 09 mov 9, %g1
40009b64: c2 22 00 00 st %g1, [ %o0 ]
40009b68: 81 c7 e0 08 ret
40009b6c: 81 e8 00 00 restore
40003028 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40003028: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
4000302c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40003030: 82 10 61 40 or %g1, 0x140, %g1 ! 4001ed40 <rtems_malloc_statistics>
40003034: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
40003038: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
4000303c: 84 00 a0 01 inc %g2
if ( !ptr )
40003040: 80 a6 20 00 cmp %i0, 0
40003044: 02 80 00 15 be 40003098 <free+0x70>
40003048: 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()) &&
4000304c: 03 10 00 7c sethi %hi(0x4001f000), %g1
40003050: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 4001f3c8 <_System_state_Current>
40003054: 80 a0 60 03 cmp %g1, 3
40003058: 02 80 00 17 be 400030b4 <free+0x8c> <== ALWAYS TAKEN
4000305c: 03 10 00 7a sethi %hi(0x4001e800), %g1
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40003060: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 4001ea90 <rtems_malloc_statistics_helpers>
40003064: 80 a0 60 00 cmp %g1, 0
40003068: 02 80 00 06 be 40003080 <free+0x58>
4000306c: 3b 10 00 78 sethi %hi(0x4001e000), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
40003070: c2 00 60 08 ld [ %g1 + 8 ], %g1
40003074: 9f c0 40 00 call %g1
40003078: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
4000307c: 3b 10 00 78 sethi %hi(0x4001e000), %i5
40003080: d0 07 63 60 ld [ %i5 + 0x360 ], %o0 ! 4001e360 <RTEMS_Malloc_Heap>
40003084: 40 00 18 86 call 4000929c <_Protected_heap_Free>
40003088: 92 10 00 19 mov %i1, %o1
4000308c: 80 8a 20 ff btst 0xff, %o0
40003090: 02 80 00 04 be 400030a0 <free+0x78>
40003094: c2 07 63 60 ld [ %i5 + 0x360 ], %g1
40003098: 81 c7 e0 08 ret
4000309c: 81 e8 00 00 restore
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
400030a0: 31 10 00 73 sethi %hi(0x4001cc00), %i0
400030a4: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
400030a8: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
400030ac: 40 00 03 81 call 40003eb0 <printk>
400030b0: 91 ee 22 c0 restore %i0, 0x2c0, %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() ) {
400030b4: 40 00 00 67 call 40003250 <malloc_is_system_state_OK>
400030b8: 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()) &&
400030bc: 80 8a 20 ff btst 0xff, %o0
400030c0: 12 bf ff e8 bne 40003060 <free+0x38>
400030c4: 03 10 00 7a sethi %hi(0x4001e800), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
400030c8: 40 00 00 7c call 400032b8 <malloc_deferred_free>
400030cc: 81 e8 00 00 restore
4001b54c <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
4001b54c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
4001b550: 80 a6 60 00 cmp %i1, 0
4001b554: 02 80 00 1f be 4001b5d0 <fstat+0x84> <== NEVER TAKEN
4001b558: 03 10 00 78 sethi %hi(0x4001e000), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
4001b55c: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1 ! 4001e3a4 <rtems_libio_number_iops>
4001b560: 80 a6 00 01 cmp %i0, %g1
4001b564: 1a 80 00 15 bcc 4001b5b8 <fstat+0x6c>
4001b568: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4001b56c: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 4001ed30 <rtems_libio_iops>
4001b570: 85 2e 20 03 sll %i0, 3, %g2
4001b574: b1 2e 20 06 sll %i0, 6, %i0
4001b578: b0 26 00 02 sub %i0, %g2, %i0
4001b57c: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
4001b580: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001b584: 80 88 61 00 btst 0x100, %g1
4001b588: 02 80 00 0c be 4001b5b8 <fstat+0x6c>
4001b58c: 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) );
4001b590: 92 10 20 00 clr %o1
4001b594: 7f ff d2 f9 call 40010178 <memset>
4001b598: 90 10 00 19 mov %i1, %o0
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
4001b59c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001b5a0: 90 06 20 14 add %i0, 0x14, %o0
4001b5a4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4001b5a8: 9f c0 40 00 call %g1
4001b5ac: 92 10 00 19 mov %i1, %o1
}
4001b5b0: 81 c7 e0 08 ret
4001b5b4: 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);
4001b5b8: 7f ff d0 62 call 4000f740 <__errno>
4001b5bc: b0 10 3f ff mov -1, %i0
4001b5c0: 82 10 20 09 mov 9, %g1
4001b5c4: c2 22 00 00 st %g1, [ %o0 ]
4001b5c8: 81 c7 e0 08 ret
4001b5cc: 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 );
4001b5d0: 7f ff d0 5c call 4000f740 <__errno> <== NOT EXECUTED
4001b5d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b5d8: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
4001b5dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b5e0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b5e4: 81 e8 00 00 restore <== NOT EXECUTED
40002dfc <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) {
40002dfc: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40002e00: c2 00 62 18 ld [ %g1 + 0x218 ], %g1 ! 4001ae18 <disktab_size>
40002e04: 80 a0 40 08 cmp %g1, %o0
40002e08: 08 80 00 20 bleu 40002e88 <get_disk_entry+0x8c> <== NEVER TAKEN
40002e0c: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40002e10: c2 00 62 1c ld [ %g1 + 0x21c ], %g1 ! 4001ae1c <disktab>
40002e14: 80 a0 60 00 cmp %g1, 0
40002e18: 02 80 00 1c be 40002e88 <get_disk_entry+0x8c> <== NEVER TAKEN
40002e1c: 01 00 00 00 nop
rtems_disk_device_table *dtab = disktab + major;
40002e20: 91 2a 20 03 sll %o0, 3, %o0
40002e24: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
40002e28: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40002e2c: 80 a0 80 09 cmp %g2, %o1
40002e30: 08 80 00 16 bleu 40002e88 <get_disk_entry+0x8c> <== NEVER TAKEN
40002e34: 01 00 00 00 nop
40002e38: c2 00 40 08 ld [ %g1 + %o0 ], %g1
40002e3c: 80 a0 60 00 cmp %g1, 0
40002e40: 02 80 00 12 be 40002e88 <get_disk_entry+0x8c> <== NEVER TAKEN
40002e44: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
40002e48: 80 a2 a0 01 cmp %o2, 1
40002e4c: 12 80 00 04 bne 40002e5c <get_disk_entry+0x60>
40002e50: d0 00 40 09 ld [ %g1 + %o1 ], %o0
return dd;
}
}
return NULL;
}
40002e54: 81 c3 e0 08 retl
40002e58: 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) {
40002e5c: 80 a2 20 00 cmp %o0, 0
40002e60: 02 bf ff fd be 40002e54 <get_disk_entry+0x58> <== NEVER TAKEN
40002e64: 01 00 00 00 nop
if (!dd->deleted) {
40002e68: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
40002e6c: 80 a0 60 00 cmp %g1, 0
40002e70: 12 80 00 06 bne 40002e88 <get_disk_entry+0x8c>
40002e74: 01 00 00 00 nop
++dd->uses;
40002e78: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40002e7c: 82 00 60 01 inc %g1
40002e80: 81 c3 e0 08 retl
40002e84: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
}
40002e88: 81 c3 e0 08 retl
40002e8c: 90 10 20 00 clr %o0
400044e4 <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,
400044e4: 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);
400044e8: 40 00 05 41 call 400059ec <malloc>
400044ec: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
400044f0: 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)
400044f4: 80 a2 20 00 cmp %o0, 0
400044f8: 02 80 00 0c be 40004528 <get_sector.part.0+0x44> <== NEVER TAKEN
400044fc: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
40004500: 90 10 00 18 mov %i0, %o0
40004504: 92 07 60 04 add %i5, 4, %o1
40004508: 40 00 07 eb call 400064b4 <read>
4000450c: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
40004510: 80 a2 22 00 cmp %o0, 0x200
40004514: 02 80 00 07 be 40004530 <get_sector.part.0+0x4c> <== ALWAYS TAKEN
40004518: 82 10 20 00 clr %g1
{
free(s);
4000451c: 40 00 03 97 call 40005378 <free> <== NOT EXECUTED
40004520: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
40004524: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
s->sector_num = sector_num;
*sector = s;
return RTEMS_SUCCESSFUL;
}
40004528: 81 c7 e0 08 ret <== NOT EXECUTED
4000452c: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
{
free(s);
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
40004530: f2 27 40 00 st %i1, [ %i5 ]
*sector = s;
40004534: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
}
40004538: 81 c7 e0 08 ret
4000453c: 91 e8 00 01 restore %g0, %g1, %o0
400331f0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
400331f0: 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 );
400331f4: 03 10 00 e4 sethi %hi(0x40039000), %g1
400331f8: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 400391ac <rtems_libio_number_iops>
400331fc: 80 a6 00 01 cmp %i0, %g1
40033200: 1a 80 00 08 bcc 40033220 <getdents+0x30> <== NEVER TAKEN
40033204: ba 10 20 00 clr %i5
40033208: 03 10 01 27 sethi %hi(0x40049c00), %g1
4003320c: fa 00 60 90 ld [ %g1 + 0x90 ], %i5 ! 40049c90 <rtems_libio_iops>
40033210: 83 2e 20 03 sll %i0, 3, %g1
40033214: b1 2e 20 06 sll %i0, 6, %i0
40033218: b0 26 00 01 sub %i0, %g1, %i0
4003321c: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
40033220: 7f ff 5b 61 call 40009fa4 <rtems_filesystem_node_type>
40033224: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
40033228: 80 a2 20 00 cmp %o0, 0
4003322c: 12 80 00 09 bne 40033250 <getdents+0x60>
40033230: 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 );
40033234: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40033238: c2 00 60 08 ld [ %g1 + 8 ], %g1
4003323c: 92 10 00 19 mov %i1, %o1
40033240: 9f c0 40 00 call %g1
40033244: 94 10 00 1a mov %i2, %o2
}
40033248: 81 c7 e0 08 ret
4003324c: 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 );
40033250: 7f ff bd ba call 40022938 <__errno>
40033254: b0 10 3f ff mov -1, %i0
40033258: 82 10 20 14 mov 0x14, %g1
4003325c: c2 22 00 00 st %g1, [ %o0 ]
40033260: 81 c7 e0 08 ret
40033264: 81 e8 00 00 restore
4000eaec <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000eaec: 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;
4000eaf0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
4000eaf4: c4 02 20 0c ld [ %o0 + 0xc ], %g2
4000eaf8: c2 00 80 00 ld [ %g2 ], %g1
4000eafc: 9f c0 40 00 call %g1
4000eb00: 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;
4000eb04: 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;
4000eb08: 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 );
4000eb0c: 90 10 00 1a mov %i2, %o0
4000eb10: 40 00 27 59 call 40018874 <.udiv>
4000eb14: 92 10 21 18 mov 0x118, %o1
4000eb18: 83 2a 20 03 sll %o0, 3, %g1
4000eb1c: 91 2a 20 05 sll %o0, 5, %o0
4000eb20: 82 00 40 08 add %g1, %o0, %g1
4000eb24: a3 28 60 03 sll %g1, 3, %l1
4000eb28: a2 24 40 01 sub %l1, %g1, %l1
4000eb2c: a2 04 40 10 add %l1, %l0, %l1
/* The directory was not empty so try to move to the desired entry in chain*/
for (
4000eb30: 80 a4 60 00 cmp %l1, 0
4000eb34: 04 80 00 34 ble 4000ec04 <imfs_dir_read+0x118> <== NEVER TAKEN
4000eb38: 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 ));
4000eb3c: 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 );
4000eb40: 80 a6 80 12 cmp %i2, %l2
4000eb44: 02 80 00 29 be 4000ebe8 <imfs_dir_read+0xfc>
4000eb48: a6 10 20 00 clr %l3
4000eb4c: 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 );
4000eb50: 10 80 00 08 b 4000eb70 <imfs_dir_read+0x84>
4000eb54: 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 (
4000eb58: 80 a4 40 1b cmp %l1, %i3
4000eb5c: 04 80 00 23 ble 4000ebe8 <imfs_dir_read+0xfc> <== NEVER TAKEN
4000eb60: 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 );
4000eb64: 80 a6 80 12 cmp %i2, %l2
4000eb68: 22 80 00 21 be,a 4000ebec <imfs_dir_read+0x100>
4000eb6c: 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 ) {
4000eb70: 80 a4 00 1b cmp %l0, %i3
4000eb74: 34 bf ff f9 bg,a 4000eb58 <imfs_dir_read+0x6c>
4000eb78: 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;
4000eb7c: 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;
4000eb80: 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 );
4000eb84: 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;
4000eb88: 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;
4000eb8c: 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;
4000eb90: 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 );
4000eb94: 90 10 00 1d mov %i5, %o0
4000eb98: 40 00 08 4f call 40010cd4 <strlen>
4000eb9c: e8 37 be f8 sth %l4, [ %fp + -264 ]
strcpy( tmp_dirent.d_name, the_jnode->name );
4000eba0: 92 10 00 1d mov %i5, %o1
4000eba4: 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 );
4000eba8: d0 37 be fa sth %o0, [ %fp + -262 ]
strcpy( tmp_dirent.d_name, the_jnode->name );
4000ebac: 40 00 05 36 call 40010084 <memcpy>
4000ebb0: 90 07 be fc add %fp, -260, %o0
memcpy(
4000ebb4: 90 06 40 13 add %i1, %l3, %o0
4000ebb8: 92 07 be e8 add %fp, -280, %o1
4000ebbc: 40 00 05 32 call 40010084 <memcpy>
4000ebc0: 94 10 21 18 mov 0x118, %o2
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset += sizeof( struct dirent );
4000ebc4: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
#include "imfs.h"
#include <string.h>
#include <dirent.h>
ssize_t imfs_dir_read(
4000ebc8: b6 06 e1 18 add %i3, 0x118, %i3
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset += sizeof( struct dirent );
4000ebcc: ba 80 e1 18 addcc %g3, 0x118, %i5
4000ebd0: b8 40 a0 00 addx %g2, 0, %i4
4000ebd4: f8 3e 20 08 std %i4, [ %i0 + 8 ]
bytes_transferred += sizeof( struct dirent );
4000ebd8: 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 (
4000ebdc: 80 a4 40 1b cmp %l1, %i3
4000ebe0: 14 bf ff e1 bg 4000eb64 <imfs_dir_read+0x78> <== NEVER TAKEN
4000ebe4: 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;
4000ebe8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
4000ebec: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000ebf0: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000ebf4: 9f c0 40 00 call %g1
4000ebf8: b0 10 00 13 mov %l3, %i0
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
return bytes_transferred;
}
4000ebfc: 81 c7 e0 08 ret
4000ec00: 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;
4000ec04: 10 bf ff f9 b 4000ebe8 <imfs_dir_read+0xfc> <== NOT EXECUTED
4000ec08: a6 10 20 00 clr %l3 <== NOT EXECUTED
400271a0 <init_etc_passwd_group>:
/**
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
400271a0: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
400271a4: 03 10 01 9f sethi %hi(0x40067c00), %g1
400271a8: c4 48 61 18 ldsb [ %g1 + 0x118 ], %g2 ! 40067d18 <etc_passwd_initted.7068>
400271ac: 80 a0 a0 00 cmp %g2, 0
400271b0: 02 80 00 04 be 400271c0 <init_etc_passwd_group+0x20>
400271b4: 84 10 20 01 mov 1, %g2
400271b8: 81 c7 e0 08 ret
400271bc: 81 e8 00 00 restore
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
400271c0: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
400271c4: c4 28 61 18 stb %g2, [ %g1 + 0x118 ]
mkdir("/etc", 0777);
400271c8: 11 10 01 7d sethi %hi(0x4005f400), %o0
400271cc: 7f ff 6f 88 call 40002fec <mkdir>
400271d0: 90 12 20 10 or %o0, 0x10, %o0 ! 4005f410 <rtems_status_assoc+0x168>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
400271d4: 39 10 01 7d sethi %hi(0x4005f400), %i4
400271d8: 3b 10 01 8e sethi %hi(0x40063800), %i5
400271dc: 90 17 20 18 or %i4, 0x18, %o0
400271e0: 40 00 53 92 call 4003c028 <fopen>
400271e4: 92 17 62 a0 or %i5, 0x2a0, %o1
400271e8: 80 a2 20 00 cmp %o0, 0
400271ec: 22 80 00 0d be,a 40027220 <init_etc_passwd_group+0x80>
400271f0: 90 17 20 18 or %i4, 0x18, %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);
400271f4: 40 00 51 2f call 4003b6b0 <fclose>
400271f8: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
400271fc: 39 10 01 7d sethi %hi(0x4005f400), %i4
40027200: 92 17 62 a0 or %i5, 0x2a0, %o1
40027204: 40 00 53 89 call 4003c028 <fopen>
40027208: 90 17 20 90 or %i4, 0x90, %o0
4002720c: 80 a2 20 00 cmp %o0, 0
40027210: 22 80 00 11 be,a 40027254 <init_etc_passwd_group+0xb4>
40027214: 90 17 20 90 or %i4, 0x90, %o0
fclose(fp);
40027218: 40 00 51 26 call 4003b6b0 <fclose>
4002721c: 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) {
40027220: 13 10 01 73 sethi %hi(0x4005cc00), %o1
40027224: 40 00 53 81 call 4003c028 <fopen>
40027228: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 4005cef0 <rtems_rtc_shell_usage+0x4e8>
4002722c: b8 92 20 00 orcc %o0, 0, %i4
40027230: 02 bf ff f3 be 400271fc <init_etc_passwd_group+0x5c> <== NEVER TAKEN
40027234: 92 10 20 01 mov 1, %o1
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
40027238: 94 10 20 66 mov 0x66, %o2
4002723c: 96 10 00 1c mov %i4, %o3
40027240: 11 10 01 7d sethi %hi(0x4005f400), %o0
40027244: 40 00 58 48 call 4003d364 <fwrite>
40027248: 90 12 20 28 or %o0, 0x28, %o0 ! 4005f428 <rtems_status_assoc+0x180>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
4002724c: 10 bf ff ea b 400271f4 <init_etc_passwd_group+0x54>
40027250: 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) {
40027254: 13 10 01 73 sethi %hi(0x4005cc00), %o1
40027258: 40 00 53 74 call 4003c028 <fopen>
4002725c: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 4005cef0 <rtems_rtc_shell_usage+0x4e8>
40027260: b0 92 20 00 orcc %o0, 0, %i0
40027264: 02 bf ff d5 be 400271b8 <init_etc_passwd_group+0x18> <== NEVER TAKEN
40027268: 92 10 20 01 mov 1, %o1
fprintf( fp, "root:x:0:root\n"
4002726c: 11 10 01 7d sethi %hi(0x4005f400), %o0
40027270: 94 10 20 2a mov 0x2a, %o2
40027274: 96 10 00 18 mov %i0, %o3
40027278: 40 00 58 3b call 4003d364 <fwrite>
4002727c: 90 12 20 a0 or %o0, 0xa0, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
40027280: 40 00 51 0c call 4003b6b0 <fclose>
40027284: 81 e8 00 00 restore
40005c44 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
40005c44: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
40005c48: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
40005c4c: 80 88 60 20 btst 0x20, %g1
40005c50: 32 80 00 02 bne,a 40005c58 <iproc+0x14> <== NEVER TAKEN
40005c54: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
40005c58: 80 88 62 00 btst 0x200, %g1
40005c5c: 02 80 00 0d be 40005c90 <iproc+0x4c>
40005c60: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
40005c64: 05 10 00 79 sethi %hi(0x4001e400), %g2
40005c68: c6 00 a1 60 ld [ %g2 + 0x160 ], %g3 ! 4001e560 <__ctype_ptr__>
40005c6c: 84 10 00 18 mov %i0, %g2
40005c70: b0 00 c0 18 add %g3, %i0, %i0
40005c74: c6 0e 20 01 ldub [ %i0 + 1 ], %g3
40005c78: 86 08 e0 03 and %g3, 3, %g3
40005c7c: 80 a0 e0 01 cmp %g3, 1
40005c80: 22 80 00 02 be,a 40005c88 <iproc+0x44>
40005c84: 84 00 a0 20 add %g2, 0x20, %g2
40005c88: b0 08 a0 ff and %g2, 0xff, %i0
if (c == '\r') {
40005c8c: 80 a6 20 0d cmp %i0, 0xd
40005c90: 02 80 00 1d be 40005d04 <iproc+0xc0>
40005c94: 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)) {
40005c98: 02 80 00 44 be 40005da8 <iproc+0x164>
40005c9c: 80 a6 20 00 cmp %i0, 0
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40005ca0: 32 80 00 1f bne,a 40005d1c <iproc+0xd8> <== ALWAYS TAKEN
40005ca4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
40005ca8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40005cac: 05 10 00 78 sethi %hi(0x4001e000), %g2
40005cb0: c4 00 a3 e4 ld [ %g2 + 0x3e4 ], %g2 ! 4001e3e4 <rtems_termios_cbufsize>
40005cb4: 84 00 bf ff add %g2, -1, %g2
40005cb8: 80 a0 40 02 cmp %g1, %g2
40005cbc: 1a 80 00 10 bcc 40005cfc <iproc+0xb8> <== NEVER TAKEN
40005cc0: 01 00 00 00 nop
if (tty->termios.c_lflag & ECHO)
40005cc4: c4 06 60 3c ld [ %i1 + 0x3c ], %g2
40005cc8: 80 88 a0 08 btst 8, %g2
40005ccc: 12 80 00 3c bne 40005dbc <iproc+0x178> <== ALWAYS TAKEN
40005cd0: 84 00 60 01 add %g1, 1, %g2
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
40005cd4: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
40005cd8: f0 28 c0 01 stb %i0, [ %g3 + %g1 ] <== NOT EXECUTED
40005cdc: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
}
return 0;
40005ce0: 81 c7 e0 08 ret <== NOT EXECUTED
40005ce4: 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)
40005ce8: 80 a0 60 00 cmp %g1, 0
40005cec: 02 80 00 04 be 40005cfc <iproc+0xb8>
40005cf0: 90 10 00 19 mov %i1, %o0
40005cf4: 7f ff ff 5f call 40005a70 <erase.part.2>
40005cf8: 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;
40005cfc: 81 c7 e0 08 ret
40005d00: 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)
40005d04: 80 88 60 80 btst 0x80, %g1
40005d08: 12 bf ff fd bne 40005cfc <iproc+0xb8> <== NEVER TAKEN
40005d0c: 80 88 61 00 btst 0x100, %g1
return 0;
if (tty->termios.c_iflag & ICRNL)
40005d10: 32 80 00 02 bne,a 40005d18 <iproc+0xd4> <== ALWAYS TAKEN
40005d14: 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)) {
40005d18: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005d1c: 80 88 60 02 btst 2, %g1
40005d20: 22 bf ff e3 be,a 40005cac <iproc+0x68>
40005d24: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
if (c == tty->termios.c_cc[VERASE]) {
40005d28: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
40005d2c: 80 a0 80 18 cmp %g2, %i0
40005d30: 22 bf ff ee be,a 40005ce8 <iproc+0xa4>
40005d34: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
40005d38: c4 0e 60 44 ldub [ %i1 + 0x44 ], %g2
40005d3c: 80 a0 80 18 cmp %g2, %i0
40005d40: 22 80 00 2d be,a 40005df4 <iproc+0x1b0>
40005d44: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
40005d48: c4 0e 60 45 ldub [ %i1 + 0x45 ], %g2
40005d4c: 80 a0 80 18 cmp %g2, %i0
40005d50: 02 80 00 42 be 40005e58 <iproc+0x214> <== NEVER TAKEN
40005d54: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
40005d58: 02 80 00 33 be 40005e24 <iproc+0x1e0>
40005d5c: 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]) ||
40005d60: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
40005d64: 80 a0 80 18 cmp %g2, %i0
40005d68: 02 80 00 07 be 40005d84 <iproc+0x140> <== NEVER TAKEN
40005d6c: 80 88 60 08 btst 8, %g1
40005d70: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
40005d74: 80 a0 80 18 cmp %g2, %i0
40005d78: 32 bf ff cd bne,a 40005cac <iproc+0x68> <== ALWAYS TAKEN
40005d7c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
40005d80: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40005d84: 12 80 00 18 bne 40005de4 <iproc+0x1a0> <== NOT EXECUTED
40005d88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
40005d8c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40005d90: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
40005d94: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED
40005d98: f0 28 c0 01 stb %i0, [ %g3 + %g1 ] <== NOT EXECUTED
40005d9c: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
return 1;
40005da0: 81 c7 e0 08 ret <== NOT EXECUTED
40005da4: 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)) {
40005da8: 80 88 60 40 btst 0x40, %g1
40005dac: 32 bf ff db bne,a 40005d18 <iproc+0xd4> <== NEVER TAKEN
40005db0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40005db4: 10 bf ff da b 40005d1c <iproc+0xd8>
40005db8: 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);
40005dbc: 90 10 00 18 mov %i0, %o0
40005dc0: 7f ff ff 0b call 400059ec <echo>
40005dc4: 92 10 00 19 mov %i1, %o1
40005dc8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
tty->cbuf[tty->ccount++] = c;
40005dcc: c6 06 60 1c ld [ %i1 + 0x1c ], %g3
40005dd0: 84 00 60 01 add %g1, 1, %g2
40005dd4: f0 28 c0 01 stb %i0, [ %g3 + %g1 ]
40005dd8: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
}
return 0;
40005ddc: 81 c7 e0 08 ret
40005de0: 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);
40005de4: 7f ff ff 02 call 400059ec <echo> <== NOT EXECUTED
40005de8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
40005dec: 10 bf ff e9 b 40005d90 <iproc+0x14c> <== NOT EXECUTED
40005df0: 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)
40005df4: 80 a0 a0 00 cmp %g2, 0
40005df8: 02 bf ff c1 be 40005cfc <iproc+0xb8> <== NEVER TAKEN
40005dfc: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
40005e00: 02 80 00 18 be 40005e60 <iproc+0x21c> <== NEVER TAKEN
40005e04: 80 88 60 10 btst 0x10, %g1
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
40005e08: 02 80 00 19 be 40005e6c <iproc+0x228> <== NEVER TAKEN
40005e0c: 90 10 00 19 mov %i1, %o0
40005e10: 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;
40005e14: 7f ff ff 17 call 40005a70 <erase.part.2>
40005e18: b0 10 20 00 clr %i0
40005e1c: 81 c7 e0 08 ret
40005e20: 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))
40005e24: 22 80 00 06 be,a 40005e3c <iproc+0x1f8> <== NEVER TAKEN
40005e28: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40005e2c: 90 10 20 0a mov 0xa, %o0
40005e30: 7f ff fe ef call 400059ec <echo>
40005e34: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
40005e38: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40005e3c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
40005e40: 86 10 20 0a mov 0xa, %g3
40005e44: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
40005e48: 82 00 60 01 inc %g1
40005e4c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
return 1;
40005e50: 81 c7 e0 08 ret
40005e54: 91 e8 20 01 restore %g0, 1, %o0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
40005e58: 81 c7 e0 08 ret <== NOT EXECUTED
40005e5c: 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;
40005e60: 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;
40005e64: 81 c7 e0 08 ret <== NOT EXECUTED
40005e68: 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;
40005e6c: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
40005e70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005e74: 7f ff fe de call 400059ec <echo> <== NOT EXECUTED
40005e78: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
40005e7c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
40005e80: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40005e84: 02 bf ff 9e be 40005cfc <iproc+0xb8> <== NOT EXECUTED
40005e88: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
echo ('\n', tty);
40005e8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005e90: 7f ff fe d7 call 400059ec <echo> <== NOT EXECUTED
40005e94: b0 10 20 00 clr %i0 <== NOT EXECUTED
40005e98: 81 c7 e0 08 ret <== NOT EXECUTED
40005e9c: 81 e8 00 00 restore <== NOT EXECUTED
4001b9b8 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
4001b9b8: 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() )
4001b9bc: 7f ff ff 10 call 4001b5fc <getpid>
4001b9c0: 01 00 00 00 nop
4001b9c4: 80 a2 00 18 cmp %o0, %i0
4001b9c8: 12 80 00 af bne 4001bc84 <killinfo+0x2cc>
4001b9cc: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
4001b9d0: 02 80 00 b3 be 4001bc9c <killinfo+0x2e4>
4001b9d4: 82 06 7f ff add %i1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001b9d8: 80 a0 60 1f cmp %g1, 0x1f
4001b9dc: 18 80 00 b0 bgu 4001bc9c <killinfo+0x2e4>
4001b9e0: 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 )
4001b9e4: 31 10 00 7d sethi %hi(0x4001f400), %i0
4001b9e8: a3 2e 60 04 sll %i1, 4, %l1
4001b9ec: b0 16 20 30 or %i0, 0x30, %i0
4001b9f0: 84 24 40 10 sub %l1, %l0, %g2
4001b9f4: 84 06 00 02 add %i0, %g2, %g2
4001b9f8: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4001b9fc: 80 a0 a0 01 cmp %g2, 1
4001ba00: 02 80 00 9f be 4001bc7c <killinfo+0x2c4>
4001ba04: 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 ) )
4001ba08: 02 80 00 41 be 4001bb0c <killinfo+0x154>
4001ba0c: 80 a6 60 08 cmp %i1, 8
4001ba10: 02 80 00 3f be 4001bb0c <killinfo+0x154>
4001ba14: 80 a6 60 0b cmp %i1, 0xb
4001ba18: 02 80 00 3d be 4001bb0c <killinfo+0x154>
4001ba1c: ba 10 20 01 mov 1, %i5
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
4001ba20: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
4001ba24: fa 27 bf f8 st %i5, [ %fp + -8 ]
if ( !value ) {
4001ba28: 80 a6 a0 00 cmp %i2, 0
4001ba2c: 02 80 00 3e be 4001bb24 <killinfo+0x16c>
4001ba30: bb 2f 40 01 sll %i5, %g1, %i5
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
4001ba34: c2 06 80 00 ld [ %i2 ], %g1
4001ba38: 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;
4001ba3c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4001ba40: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 4001eec0 <_Thread_Dispatch_disable_level>
++level;
4001ba44: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4001ba48: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ]
*/
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 );
4001ba4c: 11 10 00 79 sethi %hi(0x4001e400), %o0
4001ba50: 7f ff b0 ca call 40007d78 <_API_extensions_Add_post_switch>
4001ba54: 90 12 20 a8 or %o0, 0xa8, %o0 ! 4001e4a8 <_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;
4001ba58: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001ba5c: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 4001f3e0 <_Per_CPU_Information+0x10>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
4001ba60: c2 02 21 50 ld [ %o0 + 0x150 ], %g1
4001ba64: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1
4001ba68: 80 af 40 01 andncc %i5, %g1, %g0
4001ba6c: 12 80 00 17 bne 4001bac8 <killinfo+0x110>
4001ba70: 09 10 00 7d sethi %hi(0x4001f400), %g4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001ba74: c2 01 21 bc ld [ %g4 + 0x1bc ], %g1 ! 4001f5bc <_POSIX_signals_Wait_queue>
4001ba78: 88 11 21 bc or %g4, 0x1bc, %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 );
4001ba7c: 88 01 20 04 add %g4, 4, %g4
4001ba80: 80 a0 40 04 cmp %g1, %g4
4001ba84: 32 80 00 0d bne,a 4001bab8 <killinfo+0x100>
4001ba88: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001ba8c: 10 80 00 28 b 4001bb2c <killinfo+0x174>
4001ba90: 03 10 00 78 sethi %hi(0x4001e000), %g1
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
4001ba94: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2
4001ba98: 80 af 40 02 andncc %i5, %g2, %g0
4001ba9c: 12 80 00 0b bne 4001bac8 <killinfo+0x110>
4001baa0: 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 ) {
4001baa4: 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 );
4001baa8: 80 a0 40 04 cmp %g1, %g4
4001baac: 22 80 00 20 be,a 4001bb2c <killinfo+0x174> <== ALWAYS TAKEN
4001bab0: 03 10 00 78 sethi %hi(0x4001e000), %g1
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
4001bab4: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 4001e030 <__mprec_tinytens+0x8><== NOT EXECUTED
4001bab8: 80 8f 40 02 btst %i5, %g2
4001babc: 02 bf ff f6 be 4001ba94 <killinfo+0xdc>
4001bac0: 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 ) {
4001bac4: 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 ) ) {
4001bac8: 92 10 00 19 mov %i1, %o1
4001bacc: 40 00 00 8b call 4001bcf8 <_POSIX_signals_Unblock_thread>
4001bad0: 94 07 bf f4 add %fp, -12, %o2
4001bad4: 80 8a 20 ff btst 0xff, %o0
4001bad8: 12 80 00 09 bne 4001bafc <killinfo+0x144>
4001badc: 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 );
4001bae0: 40 00 00 7d call 4001bcd4 <_POSIX_signals_Set_process_signals>
4001bae4: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
4001bae8: a0 24 40 10 sub %l1, %l0, %l0
4001baec: c2 06 00 10 ld [ %i0 + %l0 ], %g1
4001baf0: 80 a0 60 02 cmp %g1, 2
4001baf4: 02 80 00 4f be 4001bc30 <killinfo+0x278>
4001baf8: 11 10 00 7d sethi %hi(0x4001f400), %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();
4001bafc: 7f ff b8 f3 call 40009ec8 <_Thread_Enable_dispatch>
4001bb00: b0 10 20 00 clr %i0
4001bb04: 81 c7 e0 08 ret
4001bb08: 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 );
4001bb0c: 40 00 01 13 call 4001bf58 <pthread_self>
4001bb10: 01 00 00 00 nop
4001bb14: 40 00 00 d2 call 4001be5c <pthread_kill>
4001bb18: 92 10 00 19 mov %i1, %o1
4001bb1c: 81 c7 e0 08 ret
4001bb20: 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;
4001bb24: 10 bf ff c6 b 4001ba3c <killinfo+0x84>
4001bb28: c0 27 bf fc clr [ %fp + -4 ]
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001bb2c: f8 08 62 dc ldub [ %g1 + 0x2dc ], %i4
4001bb30: 1b 10 00 7b sethi %hi(0x4001ec00), %o5
4001bb34: b8 07 20 01 inc %i4
4001bb38: 9a 13 62 2c or %o5, 0x22c, %o5
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
4001bb3c: 90 10 20 00 clr %o0
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
4001bb40: 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);
4001bb44: 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 ] )
4001bb48: c2 03 40 00 ld [ %o5 ], %g1
4001bb4c: 80 a0 60 00 cmp %g1, 0
4001bb50: 22 80 00 31 be,a 4001bc14 <killinfo+0x25c> <== NEVER TAKEN
4001bb54: 9a 03 60 04 add %o5, 4, %o5 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
4001bb58: c2 00 60 04 ld [ %g1 + 4 ], %g1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
4001bb5c: f6 10 60 10 lduh [ %g1 + 0x10 ], %i3
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001bb60: 80 a6 e0 00 cmp %i3, 0
4001bb64: 02 80 00 2b be 4001bc10 <killinfo+0x258>
4001bb68: f4 00 60 1c ld [ %g1 + 0x1c ], %i2
4001bb6c: 84 10 20 01 mov 1, %g2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
4001bb70: 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 ];
4001bb74: c6 06 80 03 ld [ %i2 + %g3 ], %g3
if ( !the_thread )
4001bb78: 80 a0 e0 00 cmp %g3, 0
4001bb7c: 22 80 00 22 be,a 4001bc04 <killinfo+0x24c>
4001bb80: 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 )
4001bb84: c8 00 e0 14 ld [ %g3 + 0x14 ], %g4
4001bb88: 80 a1 00 1c cmp %g4, %i4
4001bb8c: 38 80 00 1e bgu,a 4001bc04 <killinfo+0x24c>
4001bb90: 84 00 a0 01 inc %g2
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
4001bb94: de 00 e1 50 ld [ %g3 + 0x150 ], %o7
4001bb98: de 03 e0 d0 ld [ %o7 + 0xd0 ], %o7
4001bb9c: 80 af 40 0f andncc %i5, %o7, %g0
4001bba0: 22 80 00 19 be,a 4001bc04 <killinfo+0x24c>
4001bba4: 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 ) {
4001bba8: 80 a1 00 1c cmp %g4, %i4
4001bbac: 2a 80 00 14 bcs,a 4001bbfc <killinfo+0x244>
4001bbb0: 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 ) ) {
4001bbb4: 80 a2 20 00 cmp %o0, 0
4001bbb8: 22 80 00 13 be,a 4001bc04 <killinfo+0x24c> <== NEVER TAKEN
4001bbbc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001bbc0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001bbc4: 80 a0 60 00 cmp %g1, 0
4001bbc8: 22 80 00 0f be,a 4001bc04 <killinfo+0x24c> <== NEVER TAKEN
4001bbcc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
4001bbd0: de 00 e0 10 ld [ %g3 + 0x10 ], %o7
4001bbd4: 80 a3 e0 00 cmp %o7, 0
4001bbd8: 22 80 00 09 be,a 4001bbfc <killinfo+0x244>
4001bbdc: 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) ) {
4001bbe0: 80 88 40 0b btst %g1, %o3
4001bbe4: 32 80 00 08 bne,a 4001bc04 <killinfo+0x24c>
4001bbe8: 84 00 a0 01 inc %g2
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4001bbec: 80 8b c0 0b btst %o7, %o3
4001bbf0: 22 80 00 05 be,a 4001bc04 <killinfo+0x24c>
4001bbf4: 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 ) ) {
4001bbf8: b8 10 00 04 mov %g4, %i4
4001bbfc: 90 10 00 03 mov %g3, %o0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001bc00: 84 00 a0 01 inc %g2
4001bc04: 80 a6 c0 02 cmp %i3, %g2
4001bc08: 1a bf ff db bcc 4001bb74 <killinfo+0x1bc>
4001bc0c: 87 28 a0 02 sll %g2, 2, %g3
4001bc10: 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++) {
4001bc14: 80 a3 40 0c cmp %o5, %o4
4001bc18: 32 bf ff cd bne,a 4001bb4c <killinfo+0x194>
4001bc1c: c2 03 40 00 ld [ %o5 ], %g1
}
}
}
}
if ( interested ) {
4001bc20: 80 a2 20 00 cmp %o0, 0
4001bc24: 12 bf ff aa bne 4001bacc <killinfo+0x114>
4001bc28: 92 10 00 19 mov %i1, %o1
4001bc2c: 30 bf ff ad b,a 4001bae0 <killinfo+0x128>
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
4001bc30: 7f ff b0 b7 call 40007f0c <_Chain_Get>
4001bc34: 90 12 21 b0 or %o0, 0x1b0, %o0
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
4001bc38: 92 92 20 00 orcc %o0, 0, %o1
4001bc3c: 02 80 00 1e be 4001bcb4 <killinfo+0x2fc>
4001bc40: 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 );
4001bc44: 11 10 00 7d sethi %hi(0x4001f400), %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001bc48: c2 22 60 08 st %g1, [ %o1 + 8 ]
4001bc4c: c2 07 bf f8 ld [ %fp + -8 ], %g1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001bc50: 90 12 22 28 or %o0, 0x228, %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001bc54: c2 22 60 0c st %g1, [ %o1 + 0xc ]
4001bc58: c2 07 bf fc ld [ %fp + -4 ], %g1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001bc5c: 90 02 00 10 add %o0, %l0, %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001bc60: c2 22 60 10 st %g1, [ %o1 + 0x10 ]
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001bc64: 7f ff b0 9f call 40007ee0 <_Chain_Append>
4001bc68: 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();
4001bc6c: 7f ff b8 97 call 40009ec8 <_Thread_Enable_dispatch>
4001bc70: 01 00 00 00 nop
4001bc74: 81 c7 e0 08 ret
4001bc78: 81 e8 00 00 restore
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
4001bc7c: 81 c7 e0 08 ret
4001bc80: 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 );
4001bc84: 7f ff ce af call 4000f740 <__errno>
4001bc88: b0 10 3f ff mov -1, %i0
4001bc8c: 82 10 20 03 mov 3, %g1
4001bc90: c2 22 00 00 st %g1, [ %o0 ]
4001bc94: 81 c7 e0 08 ret
4001bc98: 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 );
4001bc9c: 7f ff ce a9 call 4000f740 <__errno>
4001bca0: b0 10 3f ff mov -1, %i0
4001bca4: 82 10 20 16 mov 0x16, %g1
4001bca8: c2 22 00 00 st %g1, [ %o0 ]
4001bcac: 81 c7 e0 08 ret
4001bcb0: 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();
4001bcb4: 7f ff b8 85 call 40009ec8 <_Thread_Enable_dispatch>
4001bcb8: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
4001bcbc: 7f ff ce a1 call 4000f740 <__errno>
4001bcc0: 01 00 00 00 nop
4001bcc4: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
4001bcc8: c2 22 00 00 st %g1, [ %o0 ]
4001bccc: 81 c7 e0 08 ret
4001bcd0: 81 e8 00 00 restore
400038f4 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
400038f4: 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()))
400038f8: 03 10 00 7c sethi %hi(0x4001f000), %g1
400038fc: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 4001f3c8 <_System_state_Current>
40003900: 80 a0 60 03 cmp %g1, 3
40003904: 02 80 00 04 be 40003914 <libc_wrapup+0x20> <== ALWAYS TAKEN
40003908: 3b 10 00 79 sethi %hi(0x4001e400), %i5
4000390c: 81 c7 e0 08 ret <== NOT EXECUTED
40003910: 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) {
40003914: 05 10 00 76 sethi %hi(0x4001d800), %g2
40003918: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
4000391c: f8 00 a0 b0 ld [ %g2 + 0xb0 ], %i4
40003920: 80 a0 40 1c cmp %g1, %i4
40003924: 02 80 00 05 be 40003938 <libc_wrapup+0x44>
40003928: 01 00 00 00 nop
_wrapup_reent(_global_impure_ptr);
4000392c: 40 00 32 b4 call 400103fc <_wrapup_reent>
40003930: 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;
40003934: f8 27 61 68 st %i4, [ %i5 + 0x168 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
40003938: 40 00 2f d4 call 4000f888 <fclose>
4000393c: d0 07 20 04 ld [ %i4 + 4 ], %o0
fclose (stdout);
40003940: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
40003944: 40 00 2f d1 call 4000f888 <fclose>
40003948: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
4000394c: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
40003950: f0 00 60 0c ld [ %g1 + 0xc ], %i0
40003954: 40 00 2f cd call 4000f888 <fclose>
40003958: 81 e8 00 00 restore
40003390 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
40003390: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
40003394: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40003398: 82 10 61 40 or %g1, 0x140, %g1 ! 4001ed40 <rtems_malloc_statistics>
4000339c: c4 00 60 04 ld [ %g1 + 4 ], %g2
400033a0: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
400033a4: 7f ff ff b8 call 40003284 <malloc_deferred_frees_process>
400033a8: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
400033ac: 80 a6 20 00 cmp %i0, 0
400033b0: 02 80 00 25 be 40003444 <malloc+0xb4>
400033b4: 03 10 00 7c sethi %hi(0x4001f000), %g1
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
400033b8: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 4001f3c8 <_System_state_Current>
400033bc: 80 a0 60 03 cmp %g1, 3
400033c0: 02 80 00 1c be 40003430 <malloc+0xa0>
400033c4: 39 10 00 78 sethi %hi(0x4001e000), %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 );
400033c8: d0 07 23 60 ld [ %i4 + 0x360 ], %o0 ! 4001e360 <RTEMS_Malloc_Heap>
400033cc: 92 10 00 18 mov %i0, %o1
400033d0: 94 10 20 00 clr %o2
400033d4: 40 00 17 a4 call 40009264 <_Protected_heap_Allocate_aligned_with_boundary>
400033d8: 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 ) {
400033dc: ba 92 20 00 orcc %o0, 0, %i5
400033e0: 02 80 00 1c be 40003450 <malloc+0xc0>
400033e4: d0 07 23 60 ld [ %i4 + 0x360 ], %o0
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
400033e8: 03 10 00 7a sethi %hi(0x4001e800), %g1
400033ec: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 4001ea8c <rtems_malloc_dirty_helper>
400033f0: 80 a0 60 00 cmp %g1, 0
400033f4: 02 80 00 04 be 40003404 <malloc+0x74>
400033f8: 90 10 00 1d mov %i5, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
400033fc: 9f c0 40 00 call %g1
40003400: 92 10 00 18 mov %i0, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40003404: 03 10 00 7a sethi %hi(0x4001e800), %g1
40003408: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 4001ea90 <rtems_malloc_statistics_helpers>
4000340c: 80 a0 60 00 cmp %g1, 0
40003410: 22 80 00 06 be,a 40003428 <malloc+0x98>
40003414: b0 10 00 1d mov %i5, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
40003418: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000341c: 9f c0 40 00 call %g1
40003420: 90 10 00 1d mov %i5, %o0
return return_this;
}
40003424: b0 10 00 1d mov %i5, %i0
40003428: 81 c7 e0 08 ret
4000342c: 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() )
40003430: 7f ff ff 88 call 40003250 <malloc_is_system_state_OK>
40003434: 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()) &&
40003438: 80 8a 20 ff btst 0xff, %o0
4000343c: 12 bf ff e3 bne 400033c8 <malloc+0x38> <== ALWAYS TAKEN
40003440: 01 00 00 00 nop
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
40003444: 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;
}
40003448: 81 c7 e0 08 ret
4000344c: 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 );
40003450: 03 10 00 71 sethi %hi(0x4001c400), %g1
40003454: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 ! 4001c460 <rtems_malloc_extend_handler>
40003458: 9f c0 40 00 call %g1
4000345c: 92 10 00 18 mov %i0, %o1
if ( !return_this ) {
40003460: ba 92 20 00 orcc %o0, 0, %i5
40003464: 12 bf ff e2 bne 400033ec <malloc+0x5c> <== NEVER TAKEN
40003468: 03 10 00 7a sethi %hi(0x4001e800), %g1
errno = ENOMEM;
4000346c: 40 00 30 b5 call 4000f740 <__errno>
40003470: b0 10 00 1d mov %i5, %i0
40003474: 82 10 20 0c mov 0xc, %g1
40003478: c2 22 00 00 st %g1, [ %o0 ]
4000347c: 81 c7 e0 08 ret
40003480: 81 e8 00 00 restore
4000dc0c <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
4000dc0c: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
4000dc10: 03 10 00 7a sethi %hi(0x4001e800), %g1
4000dc14: d2 00 62 a0 ld [ %g1 + 0x2a0 ], %o1 ! 4001eaa0 <imfs_memfile_bytes_per_block>
4000dc18: 7f ff d4 55 call 40002d6c <calloc>
4000dc1c: 90 10 20 01 mov 1, %o0
if ( memory )
4000dc20: b0 92 20 00 orcc %o0, 0, %i0
4000dc24: 02 80 00 05 be 4000dc38 <memfile_alloc_block+0x2c> <== NEVER TAKEN
4000dc28: 03 10 00 7a sethi %hi(0x4001e800), %g1
memfile_blocks_allocated++;
4000dc2c: c4 00 63 b4 ld [ %g1 + 0x3b4 ], %g2 ! 4001ebb4 <memfile_blocks_allocated>
4000dc30: 84 00 a0 01 inc %g2
4000dc34: c4 20 63 b4 st %g2, [ %g1 + 0x3b4 ]
return memory;
}
4000dc38: 81 c7 e0 08 ret
4000dc3c: 81 e8 00 00 restore
4000e184 <memfile_free_blocks_in_table>:
*/
static void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
4000e184: 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++ ) {
4000e188: 80 a6 60 00 cmp %i1, 0
4000e18c: 04 80 00 0f ble 4000e1c8 <memfile_free_blocks_in_table+0x44><== NEVER TAKEN
4000e190: d0 06 00 00 ld [ %i0 ], %o0
4000e194: ba 10 00 08 mov %o0, %i5
4000e198: b8 10 20 00 clr %i4
if ( b[i] ) {
4000e19c: d0 07 40 00 ld [ %i5 ], %o0
4000e1a0: 80 a2 20 00 cmp %o0, 0
4000e1a4: 02 80 00 05 be 4000e1b8 <memfile_free_blocks_in_table+0x34>
4000e1a8: b8 07 20 01 inc %i4
memfile_free_block( b[i] );
4000e1ac: 7f ff ff ed call 4000e160 <memfile_free_block>
4000e1b0: 01 00 00 00 nop
b[i] = 0;
4000e1b4: 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++ ) {
4000e1b8: 80 a7 00 19 cmp %i4, %i1
4000e1bc: 12 bf ff f8 bne 4000e19c <memfile_free_blocks_in_table+0x18>
4000e1c0: ba 07 60 04 add %i5, 4, %i5
4000e1c4: 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 );
4000e1c8: 7f ff ff e6 call 4000e160 <memfile_free_block>
4000e1cc: 01 00 00 00 nop
*block_table = 0;
4000e1d0: c0 26 00 00 clr [ %i0 ]
4000e1d4: 81 c7 e0 08 ret
4000e1d8: 81 e8 00 00 restore
4000e818 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
4000e818: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4000e81c: 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 )
4000e820: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
4000e824: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
4000e828: 06 80 00 11 bl 4000e86c <memfile_ftruncate+0x54> <== NOT EXECUTED
4000e82c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000e830: 22 80 00 0b be,a 4000e85c <memfile_ftruncate+0x44> <== NOT EXECUTED
4000e834: 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;
4000e838: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
4000e83c: f4 27 60 54 st %i2, [ %i5 + 0x54 ] <== NOT EXECUTED
IMFS_update_atime( the_jnode );
4000e840: 90 07 bf f8 add %fp, -8, %o0 <== NOT EXECUTED
4000e844: 7f ff d2 23 call 400030d0 <gettimeofday> <== NOT EXECUTED
4000e848: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000e84c: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
4000e850: c2 27 60 40 st %g1, [ %i5 + 0x40 ] <== NOT EXECUTED
return 0;
}
4000e854: 81 c7 e0 08 ret <== NOT EXECUTED
4000e858: 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 )
4000e85c: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
4000e860: 3a bf ff f7 bcc,a 4000e83c <memfile_ftruncate+0x24> <== NOT EXECUTED
4000e864: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
return IMFS_memfile_extend( the_jnode, true, length );
4000e868: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000e86c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000e870: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000e874: 7f ff fe c4 call 4000e384 <IMFS_memfile_extend> <== NOT EXECUTED
4000e878: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4000e87c: 81 c7 e0 08 ret <== NOT EXECUTED
4000e880: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000e79c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
4000e79c: 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)
4000e7a0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000e7a4: 80 88 60 04 btst 4, %g1
4000e7a8: 02 80 00 07 be 4000e7c4 <memfile_open+0x28>
4000e7ac: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
4000e7b0: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
4000e7b4: c2 00 40 00 ld [ %g1 ], %g1
4000e7b8: 80 a0 60 05 cmp %g1, 5
4000e7bc: 22 80 00 04 be,a 4000e7cc <memfile_open+0x30> <== NEVER TAKEN
4000e7c0: 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;
4000e7c4: 81 c7 e0 08 ret
4000e7c8: 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;
4000e7cc: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
4000e7d0: 03 10 00 74 sethi %hi(0x4001d000), %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
4000e7d4: 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;
4000e7d8: 82 10 62 dc or %g1, 0x2dc, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
4000e7dc: c0 22 20 54 clr [ %o0 + 0x54 ] <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
4000e7e0: 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;
4000e7e4: 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;
4000e7e8: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
4000e7ec: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
4000e7f0: 02 bf ff f5 be 4000e7c4 <memfile_open+0x28> <== NOT EXECUTED
4000e7f4: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4000e7f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000e7fc: 7f ff ff 53 call 4000e548 <IMFS_memfile_write> <== NOT EXECUTED
4000e800: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
4000e804: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
4000e808: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000e80c: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
4000e810: 81 c7 e0 08 ret <== NOT EXECUTED
4000e814: 81 e8 00 00 restore <== NOT EXECUTED
400035a8 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
400035a8: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
400035ac: 80 a6 e0 01 cmp %i3, 1
400035b0: 18 80 00 9a bgu 40003818 <mount+0x270>
400035b4: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
400035b8: 40 00 22 ad call 4000c06c <rtems_filesystem_get_mount_handler>
400035bc: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
400035c0: a4 92 20 00 orcc %o0, 0, %l2
400035c4: 02 80 00 95 be 40003818 <mount+0x270>
400035c8: 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 : "/";
400035cc: 02 80 00 7b be 400037b8 <mount+0x210>
400035d0: 01 00 00 00 nop
}
return rv;
}
int mount(
400035d4: 40 00 35 c0 call 40010cd4 <strlen>
400035d8: 90 10 00 19 mov %i1, %o0
400035dc: 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;
400035e0: 40 00 35 bd call 40010cd4 <strlen>
400035e4: 90 10 00 1a mov %i2, %o0
}
return rv;
}
int mount(
400035e8: 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;
400035ec: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400035f0: 80 a6 20 00 cmp %i0, 0
400035f4: 02 80 00 7a be 400037dc <mount+0x234>
400035f8: 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
400035fc: 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;
40003600: 40 00 35 b5 call 40010cd4 <strlen>
40003604: 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
40003608: 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;
4000360c: 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 );
40003610: 90 10 20 01 mov 1, %o0
40003614: 7f ff fd d6 call 40002d6c <calloc>
40003618: 92 02 40 11 add %o1, %l1, %o1
if ( mt_entry != NULL ) {
4000361c: ba 92 20 00 orcc %o0, 0, %i5
40003620: 02 80 00 78 be 40003800 <mount+0x258> <== NEVER TAKEN
40003624: 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 );
40003628: 92 10 00 1a mov %i2, %o1
4000362c: 90 10 00 10 mov %l0, %o0
40003630: 40 00 32 95 call 40010084 <memcpy>
40003634: 94 10 00 14 mov %l4, %o2
mt_entry->type = str;
40003638: 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 =
4000363c: 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 ) {
40003640: 80 a6 20 00 cmp %i0, 0
40003644: 02 80 00 08 be 40003664 <mount+0xbc>
40003648: b4 04 00 14 add %l0, %l4, %i2
memcpy( str, source_or_null, source_size );
4000364c: 90 10 00 1a mov %i2, %o0
40003650: 92 10 00 18 mov %i0, %o1
40003654: 40 00 32 8c call 40010084 <memcpy>
40003658: 94 10 00 11 mov %l1, %o2
mt_entry->dev = str;
4000365c: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
40003660: b4 06 80 11 add %i2, %l1, %i2
}
memcpy( str, target, target_size );
40003664: 92 10 00 15 mov %l5, %o1
40003668: 94 10 00 13 mov %l3, %o2
4000366c: 40 00 32 86 call 40010084 <memcpy>
40003670: 90 10 00 1a mov %i2, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
40003674: 82 10 20 01 mov 1, %g1
40003678: 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;
4000367c: 03 10 00 73 sethi %hi(0x4001cc00), %g1
40003680: 82 10 62 fc or %g1, 0x2fc, %g1 ! 4001cefc <rtems_filesystem_default_pathconf>
40003684: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
40003688: 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 );
4000368c: 90 07 60 14 add %i5, 0x14, %o0
40003690: 92 10 00 16 mov %l6, %o1
40003694: 94 10 20 01 mov 1, %o2
40003698: 96 10 20 24 mov 0x24, %o3
4000369c: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
400036a0: f4 27 60 30 st %i2, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
400036a4: ec 27 60 24 st %l6, [ %i5 + 0x24 ]
400036a8: 40 00 12 29 call 40007f4c <_Chain_Initialize>
400036ac: 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 );
400036b0: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
400036b4: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
400036b8: 92 10 00 1c mov %i4, %o1
400036bc: 9f c4 80 00 call %l2
400036c0: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
if ( rv == 0 ) {
400036c4: b0 92 20 00 orcc %o0, 0, %i0
400036c8: 12 80 00 29 bne 4000376c <mount+0x1c4>
400036cc: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
400036d0: 02 80 00 58 be 40003830 <mount+0x288>
400036d4: 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 =
400036d8: 94 10 20 1f mov 0x1f, %o2
400036dc: 40 00 02 e8 call 4000427c <rtems_filesystem_eval_path_start>
400036e0: 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;
400036e4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
400036e8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400036ec: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
400036f0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
400036f4: 9f c0 40 00 call %g1
400036f8: 01 00 00 00 nop
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
400036fc: 80 8a 20 ff btst 0xff, %o0
40003700: 12 80 00 70 bne 400038c0 <mount+0x318>
40003704: 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(
40003708: 40 00 03 d6 call 40004660 <rtems_filesystem_location_copy_and_detach>
4000370c: 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 );
40003710: 40 00 04 63 call 4000489c <rtems_filesystem_location_transform_to_global>
40003714: 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 );
40003718: 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 );
4000371c: 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 );
40003720: 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;
40003724: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40003728: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
4000372c: 9f c0 40 00 call %g1
40003730: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40003734: b0 92 20 00 orcc %o0, 0, %i0
40003738: 22 80 00 11 be,a 4000377c <mount+0x1d4>
4000373c: 39 10 00 7b sethi %hi(0x4001ec00), %i4
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
40003740: 40 00 03 fd call 40004734 <rtems_filesystem_global_location_release>
40003744: 90 10 00 1c mov %i4, %o0
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40003748: 40 00 03 0d call 4000437c <rtems_filesystem_eval_path_cleanup>
4000374c: 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 ) {
40003750: 80 a6 20 00 cmp %i0, 0
40003754: 02 80 00 59 be 400038b8 <mount+0x310>
40003758: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
4000375c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40003760: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40003764: 9f c0 40 00 call %g1
40003768: 90 10 00 1d mov %i5, %o0
}
}
if ( rv != 0 ) {
free( mt_entry );
4000376c: 7f ff fe 2f call 40003028 <free>
40003770: 90 10 00 1d mov %i5, %o0
errno = EINVAL;
rv = -1;
}
return rv;
}
40003774: 81 c7 e0 08 ret
40003778: 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 );
4000377c: d0 07 21 38 ld [ %i4 + 0x138 ], %o0
40003780: 92 10 20 00 clr %o1
40003784: 40 00 0f 02 call 4000738c <rtems_semaphore_obtain>
40003788: 94 10 20 00 clr %o2
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000378c: d0 07 21 38 ld [ %i4 + 0x138 ], %o0
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
40003790: 03 10 00 78 sethi %hi(0x4001e000), %g1
40003794: 82 10 63 cc or %g1, 0x3cc, %g1 ! 4001e3cc <rtems_filesystem_mount_table>
40003798: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
4000379c: 86 00 60 04 add %g1, 4, %g3
400037a0: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
400037a4: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
400037a8: fa 20 80 00 st %i5, [ %g2 ]
400037ac: 40 00 0f 47 call 400074c8 <rtems_semaphore_release>
400037b0: c4 27 60 04 st %g2, [ %i5 + 4 ]
400037b4: 30 bf ff e5 b,a 40003748 <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;
400037b8: 40 00 35 47 call 40010cd4 <strlen>
400037bc: 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 : "/";
400037c0: 2b 10 00 73 sethi %hi(0x4001cc00), %l5
400037c4: a6 10 20 02 mov 2, %l3
400037c8: aa 15 62 f8 or %l5, 0x2f8, %l5
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400037cc: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400037d0: 80 a6 20 00 cmp %i0, 0
400037d4: 12 bf ff 8a bne 400035fc <mount+0x54> <== NEVER TAKEN
400037d8: 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
400037dc: 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;
400037e0: 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
400037e4: 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 );
400037e8: 90 10 20 01 mov 1, %o0
400037ec: 7f ff fd 60 call 40002d6c <calloc>
400037f0: 92 02 40 11 add %o1, %l1, %o1
if ( mt_entry != NULL ) {
400037f4: ba 92 20 00 orcc %o0, 0, %i5
400037f8: 12 bf ff 8c bne 40003628 <mount+0x80> <== ALWAYS TAKEN
400037fc: a0 07 60 64 add %i5, 0x64, %l0
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
40003800: 40 00 2f d0 call 4000f740 <__errno> <== NOT EXECUTED
40003804: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003808: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000380c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40003810: 81 c7 e0 08 ret <== NOT EXECUTED
40003814: 81 e8 00 00 restore <== NOT EXECUTED
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
40003818: 40 00 2f ca call 4000f740 <__errno>
4000381c: b0 10 3f ff mov -1, %i0
40003820: 82 10 20 16 mov 0x16, %g1
40003824: c2 22 00 00 st %g1, [ %o0 ]
40003828: 81 c7 e0 08 ret
4000382c: 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 );
40003830: 39 10 00 7b sethi %hi(0x4001ec00), %i4
40003834: d0 07 21 38 ld [ %i4 + 0x138 ], %o0 ! 4001ed38 <rtems_libio_semaphore>
40003838: 92 10 20 00 clr %o1
4000383c: 40 00 0e d4 call 4000738c <rtems_semaphore_obtain>
40003840: 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;
40003844: 03 10 00 78 sethi %hi(0x4001e000), %g1
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40003848: c4 00 63 cc ld [ %g1 + 0x3cc ], %g2 ! 4001e3cc <rtems_filesystem_mount_table>
4000384c: 82 10 63 cc or %g1, 0x3cc, %g1
40003850: 86 00 60 04 add %g1, 4, %g3
40003854: 80 a0 80 03 cmp %g2, %g3
40003858: 12 80 00 1f bne 400038d4 <mount+0x32c> <== NEVER TAKEN
4000385c: 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;
40003860: c6 00 60 08 ld [ %g1 + 8 ], %g3
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
40003864: d0 07 21 38 ld [ %i4 + 0x138 ], %o0
the_node->next = tail;
40003868: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
4000386c: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40003870: fa 20 c0 00 st %i5, [ %g3 ]
40003874: 40 00 0f 15 call 400074c8 <rtems_semaphore_release>
40003878: 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 );
4000387c: 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 =
40003880: 40 00 03 cd call 400047b4 <rtems_filesystem_global_location_obtain>
40003884: 90 10 00 1d mov %i5, %o0
40003888: 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 =
4000388c: 40 00 03 ca call 400047b4 <rtems_filesystem_global_location_obtain>
40003890: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
40003894: 39 10 00 78 sethi %hi(0x4001e000), %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 =
40003898: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
4000389c: d0 07 23 ec ld [ %i4 + 0x3ec ], %o0
400038a0: 92 10 00 1b mov %i3, %o1
400038a4: 40 00 03 ba call 4000478c <rtems_filesystem_global_location_assign>
400038a8: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
400038ac: d0 07 23 ec ld [ %i4 + 0x3ec ], %o0
400038b0: 40 00 03 b7 call 4000478c <rtems_filesystem_global_location_assign>
400038b4: 92 10 00 1d mov %i5, %o1
400038b8: 81 c7 e0 08 ret
400038bc: 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 );
400038c0: 90 07 bf c8 add %fp, -56, %o0
400038c4: 92 10 20 10 mov 0x10, %o1
400038c8: 40 00 01 b1 call 40003f8c <rtems_filesystem_eval_path_error>
400038cc: b0 10 3f ff mov -1, %i0
400038d0: 30 bf ff 9e b,a 40003748 <mount+0x1a0>
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
400038d4: 40 00 2f 9b call 4000f740 <__errno> <== NOT EXECUTED
400038d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400038dc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
400038e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400038e4: 40 00 0e f9 call 400074c8 <rtems_semaphore_release> <== NOT EXECUTED
400038e8: d0 07 21 38 ld [ %i4 + 0x138 ], %o0 <== NOT EXECUTED
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
400038ec: 10 bf ff 9d b 40003760 <mount+0x1b8> <== NOT EXECUTED
400038f0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
400087d4 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
400087d4: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
400087d8: 90 96 60 00 orcc %i1, 0, %o0
400087dc: 02 80 00 0b be 40008808 <mount_and_make_target_path+0x34>
400087e0: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
400087e4: 40 00 02 ea call 4000938c <rtems_mkdir>
400087e8: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
400087ec: 82 92 20 00 orcc %o0, 0, %g1
400087f0: 02 80 00 04 be 40008800 <mount_and_make_target_path+0x2c> <== ALWAYS TAKEN
400087f4: 01 00 00 00 nop
} else {
errno = EINVAL;
}
return rv;
}
400087f8: 81 c7 e0 08 ret
400087fc: 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(
40008800: 40 00 00 08 call 40008820 <mount>
40008804: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
40008808: 40 00 68 4c call 40022938 <__errno>
4000880c: 01 00 00 00 nop
40008810: 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;
40008814: 82 10 3f ff mov -1, %g1
options,
data
);
}
} else {
errno = EINVAL;
40008818: 10 bf ff f8 b 400087f8 <mount_and_make_target_path+0x24>
4000881c: c4 22 00 00 st %g2, [ %o0 ]
40007578 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
40007578: 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;
4000757c: 03 10 00 8e sethi %hi(0x40023800), %g1
40007580: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 400238c0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40007584: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
40007588: 84 00 a0 01 inc %g2
4000758c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40007590: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40007594: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
40007598: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
4000759c: a2 8e 62 00 andcc %i1, 0x200, %l1
400075a0: 12 80 00 36 bne 40007678 <mq_open+0x100>
400075a4: 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 *)
400075a8: 39 10 00 8f sethi %hi(0x40023c00), %i4
400075ac: 40 00 0c 21 call 4000a630 <_Objects_Allocate>
400075b0: 90 17 21 90 or %i4, 0x190, %o0 ! 40023d90 <_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 ) {
400075b4: ba 92 20 00 orcc %o0, 0, %i5
400075b8: 02 80 00 39 be 4000769c <mq_open+0x124> <== NEVER TAKEN
400075bc: 01 00 00 00 nop
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
400075c0: 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 );
400075c4: 35 10 00 8f sethi %hi(0x40023c00), %i2
400075c8: 92 10 00 18 mov %i0, %o1
400075cc: 90 16 a0 04 or %i2, 4, %o0
400075d0: 94 07 bf f0 add %fp, -16, %o2
400075d4: 40 00 01 42 call 40007adc <_POSIX_Name_to_id>
400075d8: 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 ) {
400075dc: b6 92 20 00 orcc %o0, 0, %i3
400075e0: 22 80 00 0f be,a 4000761c <mq_open+0xa4>
400075e4: 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) ) ) {
400075e8: 80 a6 e0 02 cmp %i3, 2
400075ec: 02 80 00 3f be 400076e8 <mq_open+0x170>
400075f0: 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 );
400075f4: 90 17 21 90 or %i4, 0x190, %o0
400075f8: 40 00 0d 06 call 4000aa10 <_Objects_Free>
400075fc: 92 10 00 1d mov %i5, %o1
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
40007600: 40 00 11 58 call 4000bb60 <_Thread_Enable_dispatch>
40007604: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
40007608: 40 00 28 15 call 4001165c <__errno>
4000760c: 01 00 00 00 nop
40007610: f6 22 00 00 st %i3, [ %o0 ]
40007614: 81 c7 e0 08 ret
40007618: 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) ) {
4000761c: 80 a6 6a 00 cmp %i1, 0xa00
40007620: 02 80 00 27 be 400076bc <mq_open+0x144>
40007624: 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 *)
40007628: 94 07 bf f8 add %fp, -8, %o2
4000762c: 40 00 0d 5f call 4000aba8 <_Objects_Get>
40007630: 90 16 a0 04 or %i2, 4, %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;
40007634: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
40007638: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
4000763c: 84 00 a0 01 inc %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007640: b8 17 21 90 or %i4, 0x190, %i4
40007644: c4 22 20 18 st %g2, [ %o0 + 0x18 ]
40007648: 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 );
4000764c: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
40007650: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
40007654: 83 28 60 02 sll %g1, 2, %g1
40007658: fa 20 80 01 st %i5, [ %g2 + %g1 ]
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
4000765c: 40 00 11 41 call 4000bb60 <_Thread_Enable_dispatch>
40007660: c0 27 60 0c clr [ %i5 + 0xc ]
_Thread_Enable_dispatch();
40007664: 40 00 11 3f call 4000bb60 <_Thread_Enable_dispatch>
40007668: 01 00 00 00 nop
return (mqd_t)the_mq_fd->Object.id;
4000766c: f0 07 60 08 ld [ %i5 + 8 ], %i0
40007670: 81 c7 e0 08 ret
40007674: 81 e8 00 00 restore
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40007678: 82 07 a0 4c add %fp, 0x4c, %g1
mode = va_arg( arg, mode_t );
attr = va_arg( arg, struct mq_attr * );
4000767c: e0 07 a0 50 ld [ %fp + 0x50 ], %l0
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40007680: 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 *)
40007684: 39 10 00 8f sethi %hi(0x40023c00), %i4
40007688: 40 00 0b ea call 4000a630 <_Objects_Allocate>
4000768c: 90 17 21 90 or %i4, 0x190, %o0 ! 40023d90 <_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 ) {
40007690: ba 92 20 00 orcc %o0, 0, %i5
40007694: 32 bf ff cc bne,a 400075c4 <mq_open+0x4c>
40007698: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_Thread_Enable_dispatch();
4000769c: 40 00 11 31 call 4000bb60 <_Thread_Enable_dispatch>
400076a0: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( ENFILE );
400076a4: 40 00 27 ee call 4001165c <__errno>
400076a8: 01 00 00 00 nop
400076ac: 82 10 20 17 mov 0x17, %g1 ! 17 <PROM_START+0x17>
400076b0: c2 22 00 00 st %g1, [ %o0 ]
400076b4: 81 c7 e0 08 ret
400076b8: 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 );
400076bc: 90 17 21 90 or %i4, 0x190, %o0
400076c0: 40 00 0c d4 call 4000aa10 <_Objects_Free>
400076c4: 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();
400076c8: 40 00 11 26 call 4000bb60 <_Thread_Enable_dispatch>
400076cc: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
400076d0: 40 00 27 e3 call 4001165c <__errno>
400076d4: 01 00 00 00 nop
400076d8: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
400076dc: c2 22 00 00 st %g1, [ %o0 ]
400076e0: 81 c7 e0 08 ret
400076e4: 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) ) ) {
400076e8: 02 bf ff c4 be 400075f8 <mq_open+0x80>
400076ec: 90 17 21 90 or %i4, 0x190, %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(
400076f0: d2 07 bf fc ld [ %fp + -4 ], %o1
400076f4: 90 10 00 18 mov %i0, %o0
400076f8: 94 10 20 01 mov 1, %o2
400076fc: 96 10 00 10 mov %l0, %o3
40007700: 40 00 1b a1 call 4000e584 <_POSIX_Message_queue_Create_support>
40007704: 98 07 bf f4 add %fp, -12, %o4
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
40007708: 80 a2 3f ff cmp %o0, -1
4000770c: 02 80 00 0d be 40007740 <mq_open+0x1c8>
40007710: c6 07 bf f4 ld [ %fp + -12 ], %g3
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
40007714: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007718: b8 17 21 90 or %i4, 0x190, %i4
4000771c: 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;
40007720: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
40007724: 83 28 60 02 sll %g1, 2, %g1
40007728: fa 20 80 01 st %i5, [ %g2 + %g1 ]
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
4000772c: 40 00 11 0d call 4000bb60 <_Thread_Enable_dispatch>
40007730: c0 27 60 0c clr [ %i5 + 0xc ]
return (mqd_t) the_mq_fd->Object.id;
40007734: f0 07 60 08 ld [ %i5 + 8 ], %i0
}
40007738: 81 c7 e0 08 ret
4000773c: 81 e8 00 00 restore
40007740: 90 17 21 90 or %i4, 0x190, %o0
40007744: 92 10 00 1d mov %i5, %o1
40007748: 40 00 0c b2 call 4000aa10 <_Objects_Free>
4000774c: 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();
40007750: 40 00 11 04 call 4000bb60 <_Thread_Enable_dispatch>
40007754: 01 00 00 00 nop
40007758: 81 c7 e0 08 ret
4000775c: 81 e8 00 00 restore
40018058 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
40018058: 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;
4001805c: 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);
40018060: 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;
40018064: 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;
40018068: 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;
4001806c: 82 10 3f ff mov -1, %g1
time_t time_ret = 0;
uint16_t time_val = 0;
40018070: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
40018074: 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;
40018078: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
4001807c: c0 27 bf 74 clr [ %fp + -140 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40018080: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40018084: 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);
40018088: c0 27 bf 80 clr [ %fp + -128 ]
4001808c: c0 27 bf 84 clr [ %fp + -124 ]
40018090: c0 27 20 08 clr [ %i4 + 8 ]
40018094: c0 27 20 0c clr [ %i4 + 0xc ]
40018098: c0 27 20 10 clr [ %i4 + 0x10 ]
4001809c: c0 27 20 14 clr [ %i4 + 0x14 ]
400180a0: c0 27 20 18 clr [ %i4 + 0x18 ]
400180a4: c0 27 20 1c clr [ %i4 + 0x1c ]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
400180a8: c0 27 bf c0 clr [ %fp + -64 ]
400180ac: c0 27 bf c4 clr [ %fp + -60 ]
400180b0: c0 27 bf c8 clr [ %fp + -56 ]
400180b4: c0 27 bf cc clr [ %fp + -52 ]
400180b8: c0 27 bf d0 clr [ %fp + -48 ]
400180bc: c0 27 bf d4 clr [ %fp + -44 ]
400180c0: c0 27 bf d8 clr [ %fp + -40 ]
400180c4: c0 27 bf dc clr [ %fp + -36 ]
400180c8: c0 27 bf e0 clr [ %fp + -32 ]
400180cc: c0 27 bf e4 clr [ %fp + -28 ]
400180d0: c0 27 bf e8 clr [ %fp + -24 ]
400180d4: c0 27 bf ec clr [ %fp + -20 ]
400180d8: c0 27 bf f0 clr [ %fp + -16 ]
400180dc: c0 27 bf f4 clr [ %fp + -12 ]
400180e0: c0 27 bf f8 clr [ %fp + -8 ]
400180e4: c0 27 bf fc clr [ %fp + -4 ]
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
400180e8: 80 a6 e1 04 cmp %i3, 0x104
400180ec: 14 80 00 e3 bg 40018478 <msdos_creat_node+0x420> <== NEVER TAKEN
400180f0: 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,
400180f4: 90 10 00 1a mov %i2, %o0
400180f8: 92 10 00 1b mov %i3, %o1
400180fc: 94 10 00 1c mov %i4, %o2
40018100: 40 00 01 37 call 400185dc <msdos_long_to_short>
40018104: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
40018108: a4 92 20 00 orcc %o0, 0, %l2
4001810c: 02 80 00 e0 be 4001848c <msdos_creat_node+0x434> <== NEVER TAKEN
40018110: 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;
40018114: c0 2f bf 8c clrb [ %fp + -116 ]
/* set up last write date and time */
time_ret = time(NULL);
40018118: 40 00 22 21 call 4002099c <time>
4001811c: 90 10 20 00 clr %o0
if ( time_ret == -1 )
40018120: 80 a2 3f ff cmp %o0, -1
40018124: 02 80 00 df be 400184a0 <msdos_creat_node+0x448> <== NEVER TAKEN
40018128: 92 07 bf 6a add %fp, -150, %o1
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
4001812c: 40 00 0c 87 call 4001b348 <msdos_date_unix2dos>
40018130: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40018134: c8 17 bf 68 lduh [ %fp + -152 ], %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40018138: 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);
4001813c: 89 29 20 10 sll %g4, 0x10, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40018140: 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);
40018144: 85 31 20 08 srl %g4, 8, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40018148: 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);
4001814c: 89 31 20 18 srl %g4, 0x18, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40018150: 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);
40018154: 84 10 80 04 or %g2, %g4, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40018158: 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);
4001815c: 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);
40018160: 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);
40018164: 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);
40018168: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
4001816c: 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) {
40018170: 80 a6 60 00 cmp %i1, 0
40018174: 02 80 00 12 be 400181bc <msdos_creat_node+0x164>
40018178: c0 27 bf 9c clr [ %fp + -100 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
4001817c: 80 a6 60 02 cmp %i1, 2
40018180: 02 80 00 89 be 400183a4 <msdos_creat_node+0x34c> <== NEVER TAKEN
40018184: 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;
40018188: 82 10 60 20 or %g1, 0x20, %g1
4001818c: 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,
40018190: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
40018194: 90 10 00 18 mov %i0, %o0
40018198: 92 10 20 01 mov 1, %o1
4001819c: 94 10 00 1a mov %i2, %o2
400181a0: 96 10 00 1b mov %i3, %o3
400181a4: 98 10 00 12 mov %l2, %o4
400181a8: 40 00 06 b8 call 40019c88 <msdos_get_name_node>
400181ac: 9a 07 bf 70 add %fp, -144, %o5
400181b0: 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;
}
400181b4: 81 c7 e0 08 ret
400181b8: 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;
400181bc: 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,
400181c0: 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;
400181c4: 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,
400181c8: 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;
400181cc: 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,
400181d0: 92 10 20 01 mov 1, %o1
400181d4: 94 10 00 1a mov %i2, %o2
400181d8: 96 10 00 1b mov %i3, %o3
400181dc: 98 10 00 12 mov %l2, %o4
400181e0: 40 00 06 aa call 40019c88 <msdos_get_name_node>
400181e4: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
400181e8: ba 92 20 00 orcc %o0, 0, %i5
400181ec: 12 bf ff f2 bne 400181b4 <msdos_creat_node+0x15c> <== NEVER TAKEN
400181f0: 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);
400181f4: 92 07 bf 70 add %fp, -144, %o1
400181f8: 7f ff e8 ac call 400124a8 <fat_file_open>
400181fc: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
40018200: ba 92 20 00 orcc %o0, 0, %i5
40018204: 32 80 00 62 bne,a 4001838c <msdos_creat_node+0x334> <== NEVER TAKEN
40018208: 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;
4001820c: f2 07 bf 6c ld [ %fp + -148 ], %i1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40018210: 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;
40018214: c0 26 60 18 clr [ %i1 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40018218: 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;
4001821c: 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,
40018220: 03 10 00 b4 sethi %hi(0x4002d000), %g1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40018224: d8 1f bf 80 ldd [ %fp + -128 ], %o4
40018228: c4 1f bf 98 ldd [ %fp + -104 ], %g2
4001822c: f4 1f bf 88 ldd [ %fp + -120 ], %i2
40018230: 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,
40018234: d2 00 61 b4 ld [ %g1 + 0x1b4 ], %o1
40018238: 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,
4001823c: d8 3f bf c0 std %o4, [ %fp + -64 ]
40018240: c4 3f bf d8 std %g2, [ %fp + -40 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40018244: d8 3f bf e0 std %o4, [ %fp + -32 ]
40018248: 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,
4001824c: f4 3f bf c8 std %i2, [ %fp + -56 ]
40018250: f8 3f bf d0 std %i4, [ %fp + -48 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40018254: f4 3f bf e8 std %i2, [ %fp + -24 ]
40018258: 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,
4001825c: 40 00 12 f2 call 4001ce24 <memcpy>
40018260: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40018264: 03 10 00 b4 sethi %hi(0x4002d000), %g1
40018268: d2 00 61 b0 ld [ %g1 + 0x1b0 ], %o1 ! 4002d1b0 <MSDOS_DOTDOT_NAME>
4001826c: 90 07 bf e0 add %fp, -32, %o0
40018270: 40 00 12 ed call 4001ce24 <memcpy>
40018274: 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)) &&
40018278: c2 04 60 20 ld [ %l1 + 0x20 ], %g1
4001827c: 80 a0 60 01 cmp %g1, 1
40018280: 22 80 00 73 be,a 4001844c <msdos_creat_node+0x3f4>
40018284: 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));
40018288: 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;
}
4001828c: 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));
40018290: 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;
}
40018294: 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)) =
40018298: 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;
}
4001829c: 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)) =
400182a0: 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;
}
400182a4: 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));
400182a8: 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));
400182ac: 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)) =
400182b0: 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)) =
400182b4: 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)) =
400182b8: 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)) =
400182bc: 84 10 c0 02 or %g3, %g2, %g2
400182c0: 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,
400182c4: 90 10 00 10 mov %l0, %o0
400182c8: 92 10 00 19 mov %i1, %o1
400182cc: 94 10 20 00 clr %o2
400182d0: 96 10 20 40 mov 0x40, %o3
400182d4: 7f ff ea e7 call 40012e70 <fat_file_write>
400182d8: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
400182dc: 80 a2 20 00 cmp %o0, 0
400182e0: 06 80 00 26 bl 40018378 <msdos_creat_node+0x320> <== NEVER TAKEN
400182e4: 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;
400182e8: c4 14 20 06 lduh [ %l0 + 6 ], %g2
400182ec: 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));
400182f0: 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;
400182f4: 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)) =
400182f8: 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));
400182fc: 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;
40018300: 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)) =
40018304: 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)) =
40018308: 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;
}
4001830c: 05 00 00 3f sethi %hi(0xfc00), %g2
40018310: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
40018314: 82 08 40 02 and %g1, %g2, %g1
40018318: 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));
4001831c: 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));
40018320: 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)) =
40018324: 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)) =
40018328: 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,
4001832c: 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)) =
40018330: 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)) =
40018334: 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,
40018338: 94 10 20 00 clr %o2
4001833c: 96 10 20 20 mov 0x20, %o3
40018340: 7f ff ea cc call 40012e70 <fat_file_write>
40018344: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
40018348: 80 a2 20 00 cmp %o0, 0
4001834c: 06 80 00 0c bl 4001837c <msdos_creat_node+0x324> <== NEVER TAKEN
40018350: 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);
40018354: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40018358: 40 00 01 74 call 40018928 <msdos_set_first_cluster_num>
4001835c: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
40018360: ba 92 20 00 orcc %o0, 0, %i5
40018364: 12 80 00 07 bne 40018380 <msdos_creat_node+0x328> <== NEVER TAKEN
40018368: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
4001836c: 7f ff e9 c9 call 40012a90 <fat_file_close>
40018370: 90 10 00 10 mov %l0, %o0
40018374: 30 bf ff 90 b,a 400181b4 <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;
40018378: 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);
4001837c: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
40018380: 7f ff e9 c4 call 40012a90 <fat_file_close> <== NOT EXECUTED
40018384: 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);
40018388: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
4001838c: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
40018390: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
40018394: 40 00 01 c9 call 40018ab8 <msdos_set_first_char4file_name><== NOT EXECUTED
40018398: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
}
4001839c: 81 c7 e0 08 ret <== NOT EXECUTED
400183a0: 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,
400183a4: 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)) )
400183a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400183ac: 32 80 00 07 bne,a 400183c8 <msdos_creat_node+0x370> <== NOT EXECUTED
400183b0: c6 0c 20 05 ldub [ %l0 + 5 ], %g3 <== NOT EXECUTED
400183b4: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2 <== NOT EXECUTED
400183b8: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
400183bc: 32 80 00 07 bne,a 400183d8 <msdos_creat_node+0x380> <== NOT EXECUTED
400183c0: 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) +
400183c4: c6 0c 20 05 ldub [ %l0 + 5 ], %g3 <== NOT EXECUTED
400183c8: c4 04 20 34 ld [ %l0 + 0x34 ], %g2 <== NOT EXECUTED
400183cc: 92 00 7f fe add %g1, -2, %o1 <== NOT EXECUTED
400183d0: 93 2a 40 03 sll %o1, %g3, %o1 <== NOT EXECUTED
400183d4: 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);
400183d8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
400183dc: c4 0c 20 02 ldub [ %l0 + 2 ], %g2 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400183e0: 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);
400183e4: 85 30 40 02 srl %g1, %g2, %g2 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400183e8: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
400183ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400183f0: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
400183f4: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
400183f8: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
400183fc: 7f ff ec 37 call 400134d8 <_fat_block_read> <== NOT EXECUTED
40018400: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
40018404: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40018408: 06 80 00 26 bl 400184a0 <msdos_creat_node+0x448> <== NOT EXECUTED
4001840c: 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);
40018410: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40018414: c4 2f bf 8d stb %g2, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40018418: 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;
4001841c: 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);
40018420: c4 37 bf 8e sth %g2, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
40018424: 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;
40018428: 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);
4001842c: 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);
40018430: c4 07 bf bc ld [ %fp + -68 ], %g2 <== NOT EXECUTED
40018434: c4 27 bf 9c st %g2, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
40018438: c4 17 bf ba lduh [ %fp + -70 ], %g2 <== NOT EXECUTED
4001843c: c4 37 bf 9a sth %g2, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
40018440: c4 17 bf b4 lduh [ %fp + -76 ], %g2 <== NOT EXECUTED
40018444: 10 bf ff 53 b 40018190 <msdos_creat_node+0x138> <== NOT EXECUTED
40018448: 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)) &&
4001844c: 80 a0 60 00 cmp %g1, 0
40018450: 32 bf ff 8f bne,a 4001828c <msdos_creat_node+0x234> <== NEVER TAKEN
40018454: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
40018458: 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)) &&
4001845c: 82 08 60 04 and %g1, 4, %g1
40018460: 80 88 60 ff btst 0xff, %g1
40018464: 22 bf ff 8a be,a 4001828c <msdos_creat_node+0x234> <== ALWAYS TAKEN
40018468: 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;
4001846c: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40018470: 10 bf ff 95 b 400182c4 <msdos_creat_node+0x26c> <== NOT EXECUTED
40018474: 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);
40018478: 40 00 0f c6 call 4001c390 <__errno> <== NOT EXECUTED
4001847c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
40018480: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40018484: 10 bf ff 4c b 400181b4 <msdos_creat_node+0x15c> <== NOT EXECUTED
40018488: 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);
4001848c: 40 00 0f c1 call 4001c390 <__errno> <== NOT EXECUTED
40018490: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
40018494: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40018498: 10 bf ff 47 b 400181b4 <msdos_creat_node+0x15c> <== NOT EXECUTED
4001849c: 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;
400184a0: 10 bf ff 45 b 400181b4 <msdos_creat_node+0x15c> <== NOT EXECUTED
400184a4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4001b4c0 <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) {
4001b4c0: 09 10 00 b8 sethi %hi(0x4002e000), %g4
4001b4c4: da 11 22 52 lduh [ %g4 + 0x252 ], %o5 ! 4002e252 <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
4001b4c8: 86 0a 67 e0 and %o1, 0x7e0, %g3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001b4cc: 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
4001b4d0: 83 30 e0 04 srl %g3, 4, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001b4d4: 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
4001b4d8: 86 20 c0 01 sub %g3, %g1, %g3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001b4dc: 99 28 a0 03 sll %g2, 3, %o4
4001b4e0: 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)
4001b4e4: 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;
4001b4e8: 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) {
4001b4ec: 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;
4001b4f0: 85 28 60 04 sll %g1, 4, %g2
4001b4f4: 82 20 80 01 sub %g2, %g1, %g1
4001b4f8: 82 00 40 03 add %g1, %g3, %g1
4001b4fc: 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) {
4001b500: 02 80 00 3a be 4001b5e8 <msdos_date_dos2unix+0x128>
4001b504: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
4001b508: d0 31 22 52 sth %o0, [ %g4 + 0x252 ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
4001b50c: 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;
4001b510: 89 32 20 09 srl %o0, 9, %g4
for (y = 0; y < year; y++)
4001b514: 84 10 20 00 clr %g2
4001b518: 88 89 20 7f andcc %g4, 0x7f, %g4
4001b51c: 12 80 00 08 bne 4001b53c <msdos_date_dos2unix+0x7c> <== ALWAYS TAKEN
4001b520: 86 10 21 6e mov 0x16e, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
4001b524: 10 80 00 2f b 4001b5e0 <msdos_date_dos2unix+0x120> <== NOT EXECUTED
4001b528: 09 10 00 b6 sethi %hi(0x4002d800), %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;
4001b52c: 86 08 a0 03 and %g2, 3, %g3
4001b530: 80 a0 00 03 cmp %g0, %g3
4001b534: 86 60 3f ff subx %g0, -1, %g3
4001b538: 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++)
4001b53c: 84 00 a0 01 inc %g2
4001b540: 80 a0 80 04 cmp %g2, %g4
4001b544: 12 bf ff fa bne 4001b52c <msdos_date_dos2unix+0x6c>
4001b548: 82 00 40 03 add %g1, %g3, %g1
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
4001b54c: 80 88 a0 03 btst 3, %g2
4001b550: 02 80 00 24 be 4001b5e0 <msdos_date_dos2unix+0x120> <== ALWAYS TAKEN
4001b554: 09 10 00 b6 sethi %hi(0x4002d800), %g4
4001b558: 09 10 00 b6 sethi %hi(0x4002d800), %g4 <== NOT EXECUTED
4001b55c: 88 11 23 14 or %g4, 0x314, %g4 ! 4002db14 <regyear> <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
4001b560: 9a 0a 21 e0 and %o0, 0x1e0, %o5
4001b564: 9b 33 60 05 srl %o5, 5, %o5
if (month == 0) {
4001b568: 80 a3 60 00 cmp %o5, 0
4001b56c: 22 80 00 0d be,a 4001b5a0 <msdos_date_dos2unix+0xe0> <== NEVER TAKEN
4001b570: 90 0a 20 1f and %o0, 0x1f, %o0 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
4001b574: 80 a3 60 01 cmp %o5, 1
4001b578: 02 80 00 09 be 4001b59c <msdos_date_dos2unix+0xdc> <== ALWAYS TAKEN
4001b57c: 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)
4001b580: 9a 03 7f ff add %o5, -1, %o5 <== NOT EXECUTED
4001b584: 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];
4001b588: c6 11 00 02 lduh [ %g4 + %g2 ], %g3 <== NOT EXECUTED
4001b58c: 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++)
4001b590: 80 a0 80 0d cmp %g2, %o5 <== NOT EXECUTED
4001b594: 12 bf ff fd bne 4001b588 <msdos_date_dos2unix+0xc8> <== NOT EXECUTED
4001b598: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
4001b59c: 90 0a 20 1f and %o0, 0x1f, %o0
4001b5a0: 90 02 3f ff add %o0, -1, %o0
4001b5a4: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
4001b5a8: 85 28 60 07 sll %g1, 7, %g2
4001b5ac: 83 28 60 09 sll %g1, 9, %g1
4001b5b0: 82 20 40 02 sub %g1, %g2, %g1
4001b5b4: 85 28 60 04 sll %g1, 4, %g2
4001b5b8: 82 20 80 01 sub %g2, %g1, %g1
4001b5bc: 85 28 60 04 sll %g1, 4, %g2
4001b5c0: 82 20 80 01 sub %g2, %g1, %g1
4001b5c4: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
4001b5c8: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_SIZE+0x128ea600>
4001b5cc: 90 00 40 02 add %g1, %g2, %o0
4001b5d0: 05 10 00 b8 sethi %hi(0x4002e000), %g2
4001b5d4: d0 20 a2 54 st %o0, [ %g2 + 0x254 ] ! 4002e254 <lastseconds>
}
return seconds + lastseconds;
}
4001b5d8: 81 c3 e0 08 retl
4001b5dc: 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;
4001b5e0: 10 bf ff e0 b 4001b560 <msdos_date_dos2unix+0xa0>
4001b5e4: 88 11 23 2c or %g4, 0x32c, %g4
4001b5e8: 03 10 00 b8 sethi %hi(0x4002e000), %g1
4001b5ec: d0 00 62 54 ld [ %g1 + 0x254 ], %o0 ! 4002e254 <lastseconds>
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
}
return seconds + lastseconds;
}
4001b5f0: 81 c3 e0 08 retl
4001b5f4: 90 02 00 09 add %o0, %o1, %o0
4001b348 <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)
{
4001b348: 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) {
4001b34c: 03 10 00 b8 sethi %hi(0x4002e000), %g1
4001b350: c4 00 62 44 ld [ %g1 + 0x244 ], %g2 ! 4002e244 <lasttime>
4001b354: 80 a0 80 18 cmp %g2, %i0
4001b358: 02 80 00 4d be 4001b48c <msdos_date_unix2dos+0x144>
4001b35c: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
4001b360: f0 20 62 44 st %i0, [ %g1 + 0x244 ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
4001b364: 7f ff 9c c4 call 40002674 <.udiv>
4001b368: 90 10 00 18 mov %i0, %o0
4001b36c: 40 00 38 63 call 400294f8 <.urem>
4001b370: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
4001b374: 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)
4001b378: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
4001b37c: 7f ff 9c be call 40002674 <.udiv>
4001b380: 90 10 00 18 mov %i0, %o0
4001b384: 40 00 38 5d call 400294f8 <.urem>
4001b388: 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)
4001b38c: 83 2a 20 0b sll %o0, 0xb, %g1
4001b390: 92 10 20 3c mov 0x3c, %o1
4001b394: ba 07 40 01 add %i5, %g1, %i5
4001b398: 40 00 38 58 call 400294f8 <.urem>
4001b39c: 90 10 00 18 mov %i0, %o0
4001b3a0: 05 10 00 b8 sethi %hi(0x4002e000), %g2
4001b3a4: 91 32 20 01 srl %o0, 1, %o0
4001b3a8: 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);
4001b3ac: 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)
4001b3b0: c2 30 a2 48 sth %g1, [ %g2 + 0x248 ]
4001b3b4: 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);
4001b3b8: 90 10 00 18 mov %i0, %o0
4001b3bc: 7f ff 9c ae call 40002674 <.udiv>
4001b3c0: 92 12 61 80 or %o1, 0x180, %o1
if (days != lastday) {
4001b3c4: 03 10 00 b8 sethi %hi(0x4002e000), %g1
4001b3c8: c4 00 62 4c ld [ %g1 + 0x24c ], %g2 ! 4002e24c <lastday>
4001b3cc: 80 a2 00 02 cmp %o0, %g2
4001b3d0: 22 80 00 37 be,a 4001b4ac <msdos_date_unix2dos+0x164>
4001b3d4: 03 10 00 b8 sethi %hi(0x4002e000), %g1
lastday = days;
4001b3d8: d0 20 62 4c st %o0, [ %g1 + 0x24c ] ! 4002e24c <lastday>
for (year = 1970;; year++) {
4001b3dc: 10 80 00 03 b 4001b3e8 <msdos_date_unix2dos+0xa0>
4001b3e0: 82 10 27 b2 mov 0x7b2, %g1
4001b3e4: 82 00 60 01 inc %g1
inc = year & 0x03 ? 365 : 366;
4001b3e8: 86 08 60 03 and %g1, 3, %g3
4001b3ec: 80 a0 00 03 cmp %g0, %g3
4001b3f0: 84 60 3f ff subx %g0, -1, %g2
4001b3f4: 84 00 a1 6d add %g2, 0x16d, %g2
if (days < inc)
4001b3f8: 80 a2 00 02 cmp %o0, %g2
4001b3fc: 3a bf ff fa bcc,a 4001b3e4 <msdos_date_unix2dos+0x9c>
4001b400: 90 22 00 02 sub %o0, %g2, %o0
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
4001b404: 80 a0 e0 00 cmp %g3, 0
4001b408: 02 80 00 1d be 4001b47c <msdos_date_unix2dos+0x134> <== ALWAYS TAKEN
4001b40c: 09 10 00 b6 sethi %hi(0x4002d800), %g4
4001b410: 09 10 00 b6 sethi %hi(0x4002d800), %g4 <== NOT EXECUTED
4001b414: 88 11 23 14 or %g4, 0x314, %g4 ! 4002db14 <regyear> <== NOT EXECUTED
for (month = 0; month < 12; month++) {
4001b418: 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,
4001b41c: 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])
4001b420: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
4001b424: 80 a0 c0 08 cmp %g3, %o0
4001b428: 18 80 00 17 bgu 4001b484 <msdos_date_unix2dos+0x13c> <== ALWAYS TAKEN
4001b42c: 84 00 a0 01 inc %g2
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
4001b430: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
4001b434: 12 bf ff fa bne 4001b41c <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
4001b438: 90 22 00 03 sub %o0, %g3, %o0 <== NOT EXECUTED
4001b43c: 84 10 21 a0 mov 0x1a0, %g2 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
4001b440: 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)
4001b444: 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)
4001b448: 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)
4001b44c: 08 80 00 06 bleu 4001b464 <msdos_date_unix2dos+0x11c> <== NEVER TAKEN
4001b450: 84 10 00 08 mov %o0, %g2
lastddate += (year - 1980) <<
4001b454: 82 00 78 44 add %g1, -1980, %g1
4001b458: 83 28 60 09 sll %g1, 9, %g1
4001b45c: 90 02 00 01 add %o0, %g1, %o0
4001b460: 84 10 00 08 mov %o0, %g2
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001b464: 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) <<
4001b468: 03 10 00 b8 sethi %hi(0x4002e000), %g1
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
4001b46c: 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) <<
4001b470: d0 30 62 50 sth %o0, [ %g1 + 0x250 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
4001b474: 81 c7 e0 08 ret
4001b478: 81 e8 00 00 restore
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
4001b47c: 10 bf ff e7 b 4001b418 <msdos_date_unix2dos+0xd0>
4001b480: 88 11 23 2c or %g4, 0x32c, %g4
4001b484: 10 bf ff ef b 4001b440 <msdos_date_unix2dos+0xf8>
4001b488: 85 28 a0 05 sll %g2, 5, %g2
4001b48c: 03 10 00 b8 sethi %hi(0x4002e000), %g1
4001b490: fa 10 62 48 lduh [ %g1 + 0x248 ], %i5 ! 4002e248 <lastdtime>
4001b494: 03 10 00 b8 sethi %hi(0x4002e000), %g1
4001b498: c4 10 62 50 lduh [ %g1 + 0x250 ], %g2 ! 4002e250 <lastddate>
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001b49c: fa 36 80 00 sth %i5, [ %i2 ]
*ddp = lastddate;
4001b4a0: c4 36 40 00 sth %g2, [ %i1 ]
4001b4a4: 81 c7 e0 08 ret
4001b4a8: 81 e8 00 00 restore
4001b4ac: c4 10 62 50 lduh [ %g1 + 0x250 ], %g2
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001b4b0: fa 36 80 00 sth %i5, [ %i2 ]
*ddp = lastddate;
4001b4b4: c4 36 40 00 sth %g2, [ %i1 ]
4001b4b8: 81 c7 e0 08 ret
4001b4bc: 81 e8 00 00 restore
40018c68 <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
)
{
40018c68: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40018c6c: 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,
40018c70: 25 10 00 b4 sethi %hi(0x4002d000), %l2
40018c74: e2 14 00 00 lduh [ %l0 ], %l1
40018c78: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
40018c7c: 29 10 00 b4 sethi %hi(0x4002d000), %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;
40018c80: 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;
40018c84: a6 10 20 00 clr %l3
40018c88: 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,
40018c8c: a4 14 a1 70 or %l2, 0x170, %l2
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
40018c90: a8 15 21 80 or %l4, 0x180, %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,
40018c94: a3 34 60 10 srl %l1, 0x10, %l1
40018c98: 92 10 00 13 mov %l3, %o1
40018c9c: 7f ff a6 3c call 4000258c <.umul>
40018ca0: 90 10 00 11 mov %l1, %o0
40018ca4: 92 10 00 19 mov %i1, %o1
40018ca8: 94 10 00 08 mov %o0, %o2
40018cac: 96 10 00 11 mov %l1, %o3
40018cb0: 90 10 00 10 mov %l0, %o0
40018cb4: 7f ff e6 b1 call 40012778 <fat_file_read>
40018cb8: 98 10 00 15 mov %l5, %o4
40018cbc: 80 a2 20 00 cmp %o0, 0
40018cc0: 02 80 00 34 be 40018d90 <msdos_dir_is_empty+0x128> <== NEVER TAKEN
40018cc4: 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)
40018cc8: 04 80 00 27 ble 40018d64 <msdos_dir_is_empty+0xfc> <== NEVER TAKEN
40018ccc: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
40018cd0: e2 14 00 00 lduh [ %l0 ], %l1
40018cd4: a3 2c 60 10 sll %l1, 0x10, %l1
40018cd8: b1 34 60 10 srl %l1, 0x10, %i0
40018cdc: 80 a6 00 08 cmp %i0, %o0
40018ce0: 12 80 00 2e bne 40018d98 <msdos_dir_is_empty+0x130> <== NEVER TAKEN
40018ce4: 80 a6 20 00 cmp %i0, 0
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
40018ce8: 02 80 00 27 be 40018d84 <msdos_dir_is_empty+0x11c> <== NEVER TAKEN
40018cec: b8 10 20 00 clr %i4
40018cf0: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
40018cf4: 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)) ==
40018cf8: f6 0f 40 00 ldub [ %i5 ], %i3
40018cfc: 80 a6 e0 e5 cmp %i3, 0xe5
40018d00: 22 80 00 1c be,a 40018d70 <msdos_dir_is_empty+0x108> <== NEVER TAKEN
40018d04: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40018d08: 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) ||
40018d0c: 82 08 60 3f and %g1, 0x3f, %g1
40018d10: 80 a0 60 0f cmp %g1, 0xf
40018d14: 02 80 00 16 be 40018d6c <msdos_dir_is_empty+0x104> <== NEVER TAKEN
40018d18: 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,
40018d1c: 92 10 00 12 mov %l2, %o1
40018d20: 40 00 14 91 call 4001df64 <strncmp>
40018d24: 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) ||
40018d28: 80 a2 20 00 cmp %o0, 0
40018d2c: 22 80 00 11 be,a 40018d70 <msdos_dir_is_empty+0x108>
40018d30: 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)),
40018d34: 90 10 00 1d mov %i5, %o0
40018d38: 92 10 00 14 mov %l4, %o1
40018d3c: 40 00 14 8a call 4001df64 <strncmp>
40018d40: 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) ||
40018d44: 80 a2 20 00 cmp %o0, 0
40018d48: 22 80 00 0a be,a 40018d70 <msdos_dir_is_empty+0x108>
40018d4c: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
40018d50: 80 a6 e0 00 cmp %i3, 0
40018d54: 12 80 00 04 bne 40018d64 <msdos_dir_is_empty+0xfc>
40018d58: b0 10 20 00 clr %i0
*/
return RC_OK;
}
j++;
}
*ret_val = true;
40018d5c: 82 10 20 01 mov 1, %g1
40018d60: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
40018d64: 81 c7 e0 08 ret
40018d68: 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)
40018d6c: 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;
40018d70: 80 a7 00 18 cmp %i4, %i0
40018d74: 0a bf ff e1 bcs 40018cf8 <msdos_dir_is_empty+0x90> <== ALWAYS TAKEN
40018d78: ba 07 60 20 add %i5, 0x20, %i5
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
40018d7c: 10 bf ff c6 b 40018c94 <msdos_dir_is_empty+0x2c> <== NOT EXECUTED
40018d80: a6 04 e0 01 inc %l3 <== NOT EXECUTED
40018d84: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5 <== NOT EXECUTED
40018d88: 10 bf ff c3 b 40018c94 <msdos_dir_is_empty+0x2c> <== NOT EXECUTED
40018d8c: a6 04 e0 01 inc %l3 <== NOT EXECUTED
}
*ret_val = true;
return RC_OK;
40018d90: 10 bf ff f3 b 40018d5c <msdos_dir_is_empty+0xf4> <== NOT EXECUTED
40018d94: 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);
40018d98: 11 10 00 b4 sethi %hi(0x4002d000), %o0 <== NOT EXECUTED
40018d9c: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
40018da0: 17 10 00 b4 sethi %hi(0x4002d000), %o3 <== NOT EXECUTED
40018da4: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
40018da8: 92 10 23 65 mov 0x365, %o1 <== NOT EXECUTED
40018dac: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED
40018db0: 7f ff af 1b call 40004a1c <__assert_func> <== NOT EXECUTED
40018db4: 96 12 e1 50 or %o3, 0x150, %o3 <== NOT EXECUTED
4001b7fc <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)
{
4001b7fc: 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;
4001b800: 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);
4001b804: 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;
4001b808: 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);
4001b80c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001b810: 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)
{
4001b814: 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;
4001b818: 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;
4001b81c: 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);
4001b820: 7f ff 9a 70 call 400021e0 <__divdi3> <== NOT EXECUTED
4001b824: c0 27 be d4 clr [ %fp + -300 ] <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001b828: 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);
4001b82c: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001b830: 7f ff 9b 91 call 40002674 <.udiv> <== NOT EXECUTED
4001b834: 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 :
4001b838: 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);
4001b83c: 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 :
4001b840: 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);
4001b844: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
4001b848: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
4001b84c: 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 :
4001b850: 02 80 00 f2 be 4001bc18 <msdos_dir_read+0x41c> <== NOT EXECUTED
4001b854: a2 24 40 08 sub %l1, %o0, %l1 <== NOT EXECUTED
4001b858: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
4001b85c: 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,
4001b860: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001b864: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001b868: 7f ff b6 e4 call 400093f8 <rtems_semaphore_obtain> <== NOT EXECUTED
4001b86c: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b870: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b874: 12 80 01 37 bne 4001bd50 <msdos_dir_read+0x554> <== NOT EXECUTED
4001b878: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
4001b87c: 02 80 00 3a be 4001b964 <msdos_dir_read+0x168> <== NOT EXECUTED
4001b880: b8 10 20 00 clr %i4 <== NOT EXECUTED
4001b884: a6 10 20 00 clr %l3 <== NOT EXECUTED
4001b888: a8 10 20 00 clr %l4 <== NOT EXECUTED
4001b88c: c0 2f be cf clrb [ %fp + -305 ] <== NOT EXECUTED
4001b890: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
4001b894: 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),
4001b898: d8 06 20 a0 ld [ %i0 + 0xa0 ], %o4 <== NOT EXECUTED
4001b89c: d6 07 be c4 ld [ %fp + -316 ], %o3 <== NOT EXECUTED
4001b8a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b8a4: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001b8a8: 7f ff db b4 call 40012778 <fat_file_read> <== NOT EXECUTED
4001b8ac: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001b8b0: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
4001b8b4: 04 80 01 1e ble 4001bd2c <msdos_dir_read+0x530> <== NOT EXECUTED
4001b8b8: 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;
4001b8bc: fa 06 20 a0 ld [ %i0 + 0xa0 ], %i5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001b8c0: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
4001b8c4: 86 88 a0 ff andcc %g2, 0xff, %g3 <== NOT EXECUTED
4001b8c8: 02 80 00 ce be 4001bc00 <msdos_dir_read+0x404> <== NOT EXECUTED
4001b8cc: 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)
4001b8d0: 10 80 00 0f b 4001b90c <msdos_dir_read+0x110> <== NOT EXECUTED
4001b8d4: 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) &&
4001b8d8: 80 a0 e0 0f cmp %g3, 0xf <== NOT EXECUTED
4001b8dc: 02 80 00 28 be 4001b97c <msdos_dir_read+0x180> <== NOT EXECUTED
4001b8e0: 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)
4001b8e4: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
4001b8e8: 80 a5 c0 16 cmp %l7, %l6 <== NOT EXECUTED
4001b8ec: 1a 80 00 1a bcc 4001b954 <msdos_dir_read+0x158> <== NOT EXECUTED
4001b8f0: c2 07 be c4 ld [ %fp + -316 ], %g1 <== NOT EXECUTED
{
char* entry = (char*) fs_info->cl_buf + i;
4001b8f4: fa 06 20 a0 ld [ %i0 + 0xa0 ], %i5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001b8f8: c4 0f 40 17 ldub [ %i5 + %l7 ], %g2 <== NOT EXECUTED
4001b8fc: 86 88 a0 ff andcc %g2, 0xff, %g3 <== NOT EXECUTED
4001b900: 02 80 00 c0 be 4001bc00 <msdos_dir_read+0x404> <== NOT EXECUTED
4001b904: 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)
4001b908: 80 a0 e0 e5 cmp %g3, 0xe5 <== NOT EXECUTED
4001b90c: 22 bf ff f7 be,a 4001b8e8 <msdos_dir_read+0xec> <== NOT EXECUTED
4001b910: 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) &&
4001b914: c6 0f 60 0b ldub [ %i5 + 0xb ], %g3 <== NOT EXECUTED
4001b918: b8 08 e0 08 and %g3, 8, %i4 <== NOT EXECUTED
4001b91c: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4001b920: 12 bf ff ee bne 4001b8d8 <msdos_dir_read+0xdc> <== NOT EXECUTED
4001b924: 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) ==
4001b928: 80 a0 e0 0f cmp %g3, 0xf <== NOT EXECUTED
4001b92c: 02 80 00 13 be 4001b978 <msdos_dir_read+0x17c> <== NOT EXECUTED
4001b930: 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)
4001b934: 02 80 00 3c be 4001ba24 <msdos_dir_read+0x228> <== NOT EXECUTED
4001b938: 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)
4001b93c: 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--;
4001b940: 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)
4001b944: 80 a5 c0 16 cmp %l7, %l6 <== NOT EXECUTED
4001b948: 0a bf ff eb bcs 4001b8f4 <msdos_dir_read+0xf8> <== NOT EXECUTED
4001b94c: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
4001b950: 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)
4001b954: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4001b958: 12 bf ff d0 bne 4001b898 <msdos_dir_read+0x9c> <== NOT EXECUTED
4001b95c: a6 04 c0 01 add %l3, %g1, %l3 <== NOT EXECUTED
4001b960: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
4001b964: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001b968: 7f ff b6 f3 call 40009534 <rtems_semaphore_release> <== NOT EXECUTED
4001b96c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
return cmpltd;
}
4001b970: 81 c7 e0 08 ret <== NOT EXECUTED
4001b974: 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)
4001b978: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
4001b97c: 02 80 00 93 be 4001bbc8 <msdos_dir_read+0x3cc> <== NOT EXECUTED
4001b980: 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) &
4001b984: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
4001b988: 84 08 a0 3f and %g2, 0x3f, %g2 <== NOT EXECUTED
4001b98c: 80 a0 80 14 cmp %g2, %l4 <== NOT EXECUTED
4001b990: 22 80 00 04 be,a 4001b9a0 <msdos_dir_read+0x1a4> <== NOT EXECUTED
4001b994: 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;
4001b998: 10 bf ff d3 b 4001b8e4 <msdos_dir_read+0xe8> <== NOT EXECUTED
4001b99c: 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)) ||
4001b9a0: c4 0f be cf ldub [ %fp + -305 ], %g2 <== NOT EXECUTED
4001b9a4: 86 0b 20 ff and %o4, 0xff, %g3 <== NOT EXECUTED
4001b9a8: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
4001b9ac: 32 bf ff ce bne,a 4001b8e4 <msdos_dir_read+0xe8> <== NOT EXECUTED
4001b9b0: 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--;
4001b9b4: a8 05 3f ff add %l4, -1, %l4 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001b9b8: 85 2d 20 02 sll %l4, 2, %g2 <== NOT EXECUTED
4001b9bc: 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;
4001b9c0: ba 07 60 01 inc %i5 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001b9c4: 94 22 80 02 sub %o2, %g2, %o2 <== NOT EXECUTED
4001b9c8: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
4001b9cc: 94 02 80 14 add %o2, %l4, %o2 <== NOT EXECUTED
4001b9d0: 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)
4001b9d4: 82 07 be e8 add %fp, -280, %g1 <== NOT EXECUTED
4001b9d8: 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))
4001b9dc: 80 a0 a0 fe cmp %g2, 0xfe <== NOT EXECUTED
4001b9e0: 18 80 00 99 bgu 4001bc44 <msdos_dir_read+0x448> <== NOT EXECUTED
4001b9e4: 9e 00 40 02 add %g1, %g2, %o7 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
4001b9e8: d6 0f 40 00 ldub [ %i5 ], %o3 <== NOT EXECUTED
4001b9ec: d6 2b e0 14 stb %o3, [ %o7 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
4001b9f0: de 4f 40 00 ldsb [ %i5 ], %o7 <== NOT EXECUTED
4001b9f4: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
4001b9f8: 02 80 00 93 be 4001bc44 <msdos_dir_read+0x448> <== NOT EXECUTED
4001b9fc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
break;
switch (q)
4001ba00: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
4001ba04: 02 80 00 92 be 4001bc4c <msdos_dir_read+0x450> <== NOT EXECUTED
4001ba08: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
4001ba0c: 02 80 00 93 be 4001bc58 <msdos_dir_read+0x45c> <== NOT EXECUTED
4001ba10: 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++)
4001ba14: 02 80 00 8c be 4001bc44 <msdos_dir_read+0x448> <== NOT EXECUTED
4001ba18: ba 07 60 02 add %i5, 2, %i5 <== NOT EXECUTED
4001ba1c: 10 bf ff ef b 4001b9d8 <msdos_dir_read+0x1dc> <== NOT EXECUTED
4001ba20: 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,
4001ba24: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001ba28: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001ba2c: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED
4001ba30: 7f ff dc 46 call 40012b48 <fat_file_ioctl> <== NOT EXECUTED
4001ba34: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
4001ba38: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001ba3c: 12 bf ff ca bne 4001b964 <msdos_dir_read+0x168> <== NOT EXECUTED
4001ba40: 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;
4001ba44: 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;
4001ba48: c4 27 be d8 st %g2, [ %fp + -296 ] <== NOT EXECUTED
4001ba4c: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001ba50: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
4001ba54: ee 27 be dc st %l7, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
4001ba58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ba5c: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
4001ba60: 7f ff da 92 call 400124a8 <fat_file_open> <== NOT EXECUTED
4001ba64: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
4001ba68: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001ba6c: 12 bf ff be bne 4001b964 <msdos_dir_read+0x168> <== NOT EXECUTED
4001ba70: 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);
4001ba74: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
4001ba78: 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;
4001ba7c: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
4001ba80: e0 27 be f4 st %l0, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
4001ba84: 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)
4001ba88: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
4001ba8c: 02 80 00 35 be 4001bb60 <msdos_dir_read+0x364> <== NOT EXECUTED
4001ba90: 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)
4001ba94: 9e 07 60 0b add %i5, 0xb, %o7 <== NOT EXECUTED
4001ba98: 84 10 00 1d mov %i5, %g2 <== NOT EXECUTED
4001ba9c: 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;
4001baa0: 10 80 00 06 b 4001bab8 <msdos_dir_read+0x2bc> <== NOT EXECUTED
4001baa4: 86 10 20 00 clr %g3 <== NOT EXECUTED
4001baa8: 80 a0 00 0c cmp %g0, %o4 <== NOT EXECUTED
4001baac: 86 40 3f ff addx %g0, -1, %g3 <== NOT EXECUTED
4001bab0: 86 08 e0 80 and %g3, 0x80, %g3 <== NOT EXECUTED
4001bab4: 86 00 ff 80 add %g3, -128, %g3 <== NOT EXECUTED
4001bab8: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
4001babc: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED
4001bac0: b9 37 20 01 srl %i4, 1, %i4 <== NOT EXECUTED
4001bac4: 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++)
4001bac8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001bacc: 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++)
4001bad0: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001bad4: 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++)
4001bad8: 12 bf ff f4 bne 4001baa8 <msdos_dir_read+0x2ac> <== NOT EXECUTED
4001badc: b8 10 00 03 mov %g3, %i4 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
4001bae0: c2 0f be cf ldub [ %fp + -305 ], %g1 <== NOT EXECUTED
4001bae4: b8 18 40 1c xor %g1, %i4, %i4 <== NOT EXECUTED
4001bae8: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4001baec: 12 80 00 1e bne 4001bb64 <msdos_dir_read+0x368> <== NOT EXECUTED
4001baf0: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001baf4: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
4001baf8: 32 80 00 1c bne,a 4001bb68 <msdos_dir_read+0x36c> <== NOT EXECUTED
4001bafc: 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);
4001bb00: 40 00 08 e7 call 4001de9c <strlen> <== NOT EXECUTED
4001bb04: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001bb08: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
4001bb0c: 90 06 40 10 add %i1, %l0, %o0 <== NOT EXECUTED
4001bb10: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
4001bb14: 40 00 04 c4 call 4001ce24 <memcpy> <== NOT EXECUTED
4001bb18: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
4001bb1c: 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);
4001bb20: 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);
4001bb24: ba 80 e1 18 addcc %g3, 0x118, %i5 <== NOT EXECUTED
4001bb28: 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);
4001bb2c: 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);
4001bb30: 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);
4001bb34: 7f ff db d7 call 40012a90 <fat_file_close> <== NOT EXECUTED
4001bb38: 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));
4001bb3c: 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)
4001bb40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001bb44: 12 bf ff 88 bne 4001b964 <msdos_dir_read+0x168> <== NOT EXECUTED
4001bb48: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
4001bb4c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4001bb50: 32 bf ff 66 bne,a 4001b8e8 <msdos_dir_read+0xec> <== NOT EXECUTED
4001bb54: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
4001bb58: 10 bf ff 83 b 4001b964 <msdos_dir_read+0x168> <== NOT EXECUTED
4001bb5c: 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 ,
4001bb60: 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)
4001bb64: 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) &&
4001bb68: c4 4e bf ff ldsb [ %i2 + -1 ], %g2 <== NOT EXECUTED
4001bb6c: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001bb70: 12 80 00 3d bne 4001bc64 <msdos_dir_read+0x468> <== NOT EXECUTED
4001bb74: 03 10 00 b6 sethi %hi(0x4002d800), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001bb78: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
4001bb7c: 32 bf ff fb bne,a 4001bb68 <msdos_dir_read+0x36c> <== NOT EXECUTED
4001bb80: 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(
4001bb84: 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) &&
4001bb88: c4 4f 60 0a ldsb [ %i5 + 0xa ], %g2 <== NOT EXECUTED
4001bb8c: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001bb90: 12 80 00 46 bne 4001bca8 <msdos_dir_read+0x4ac> <== NOT EXECUTED
4001bb94: 98 10 20 03 mov 3, %o4 <== NOT EXECUTED
4001bb98: c4 4f 60 09 ldsb [ %i5 + 9 ], %g2 <== NOT EXECUTED
4001bb9c: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001bba0: 32 80 00 42 bne,a 4001bca8 <msdos_dir_read+0x4ac> <== NOT EXECUTED
4001bba4: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
4001bba8: c4 4f 60 08 ldsb [ %i5 + 8 ], %g2 <== NOT EXECUTED
4001bbac: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001bbb0: 12 80 00 3e bne 4001bca8 <msdos_dir_read+0x4ac> <== NOT EXECUTED
4001bbb4: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
4001bbb8: 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(
4001bbbc: d2 37 be fa sth %o1, [ %fp + -262 ] <== NOT EXECUTED
4001bbc0: 10 bf ff d3 b 4001bb0c <msdos_dir_read+0x310> <== NOT EXECUTED
4001bbc4: 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) &
4001bbc8: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
4001bbcc: 22 bf ff 47 be,a 4001b8e8 <msdos_dir_read+0xec> <== NOT EXECUTED
4001bbd0: 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);
4001bbd4: 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)
4001bbd8: 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) &
4001bbdc: a8 08 a0 3f and %g2, 0x3f, %l4 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
4001bbe0: 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);
4001bbe4: c2 2f be cf stb %g1, [ %fp + -305 ] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
4001bbe8: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001bbec: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001bbf0: 40 00 04 ca call 4001cf18 <memset> <== NOT EXECUTED
4001bbf4: 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) &
4001bbf8: 10 bf ff 64 b 4001b988 <msdos_dir_read+0x18c> <== NOT EXECUTED
4001bbfc: 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);
4001bc00: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001bc04: 7f ff b6 4c call 40009534 <rtems_semaphore_release> <== NOT EXECUTED
4001bc08: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
4001bc0c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4001bc10: 81 c7 e0 08 ret <== NOT EXECUTED
4001bc14: 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) &&
4001bc18: c2 05 60 24 ld [ %l5 + 0x24 ], %g1 <== NOT EXECUTED
4001bc1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001bc20: 32 bf ff 0f bne,a 4001b85c <msdos_dir_read+0x60> <== NOT EXECUTED
4001bc24: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
4001bc28: 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) &&
4001bc2c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
4001bc30: 22 bf ff 0b be,a 4001b85c <msdos_dir_read+0x60> <== NOT EXECUTED
4001bc34: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
4001bc38: c2 05 60 18 ld [ %l5 + 0x18 ], %g1 <== NOT EXECUTED
4001bc3c: 10 bf ff 09 b 4001b860 <msdos_dir_read+0x64> <== NOT EXECUTED
4001bc40: 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')
4001bc44: 10 bf ff c2 b 4001bb4c <msdos_dir_read+0x350> <== NOT EXECUTED
4001bc48: d8 2f be cf stb %o4, [ %fp + -305 ] <== NOT EXECUTED
break;
switch (q)
{
case 4:
p += 5;
4001bc4c: ba 07 60 05 add %i5, 5, %i5 <== NOT EXECUTED
4001bc50: 10 bf ff 61 b 4001b9d4 <msdos_dir_read+0x1d8> <== NOT EXECUTED
4001bc54: b8 07 20 01 inc %i4 <== NOT EXECUTED
break;
case 10:
p += 4;
4001bc58: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
4001bc5c: 10 bf ff 5e b 4001b9d4 <msdos_dir_read+0x1d8> <== NOT EXECUTED
4001bc60: 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)
4001bc64: 84 10 00 1d mov %i5, %g2 <== NOT EXECUTED
4001bc68: d8 00 63 44 ld [ %g1 + 0x344 ], %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(
4001bc6c: 10 80 00 06 b 4001bc84 <msdos_dir_read+0x488> <== NOT EXECUTED
4001bc70: 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++));
4001bc74: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
4001bc78: 80 a0 80 1a cmp %g2, %i2 <== NOT EXECUTED
4001bc7c: 02 bf ff c3 be 4001bb88 <msdos_dir_read+0x38c> <== NOT EXECUTED
4001bc80: 86 00 e0 01 inc %g3 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
4001bc84: f8 08 80 00 ldub [ %g2 ], %i4 <== NOT EXECUTED
4001bc88: 9e 03 00 1c add %o4, %i4, %o7 <== NOT EXECUTED
4001bc8c: de 0b e0 01 ldub [ %o7 + 1 ], %o7 <== NOT EXECUTED
4001bc90: 9e 0b e0 03 and %o7, 3, %o7 <== NOT EXECUTED
4001bc94: 80 a3 e0 01 cmp %o7, 1 <== NOT EXECUTED
4001bc98: 12 bf ff f7 bne 4001bc74 <msdos_dir_read+0x478> <== NOT EXECUTED
4001bc9c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001bca0: 10 bf ff f5 b 4001bc74 <msdos_dir_read+0x478> <== NOT EXECUTED
4001bca4: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001bca8: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
4001bcac: 96 00 e0 01 add %g3, 1, %o3 <== NOT EXECUTED
4001bcb0: c2 28 c0 00 stb %g1, [ %g3 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
4001bcb4: 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)
4001bcb8: 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 */
4001bcbc: 94 02 40 0a add %o1, %o2, %o2 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
4001bcc0: 84 07 60 08 add %i5, 8, %g2 <== NOT EXECUTED
4001bcc4: 03 10 00 b6 sethi %hi(0x4002d800), %g1 <== NOT EXECUTED
while (i-- > 0) {
4001bcc8: 92 03 3f ff add %o4, -1, %o1 <== NOT EXECUTED
4001bccc: de 00 63 44 ld [ %g1 + 0x344 ], %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)
4001bcd0: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001bcd4: 10 80 00 06 b 4001bcec <msdos_dir_read+0x4f0> <== NOT EXECUTED
4001bcd8: 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++));
4001bcdc: 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) {
4001bce0: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
4001bce4: 02 80 00 0e be 4001bd1c <msdos_dir_read+0x520> <== NOT EXECUTED
4001bce8: 86 00 e0 01 inc %g3 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
4001bcec: f8 08 80 00 ldub [ %g2 ], %i4 <== NOT EXECUTED
4001bcf0: b4 03 c0 1c add %o7, %i4, %i2 <== NOT EXECUTED
4001bcf4: f4 0e a0 01 ldub [ %i2 + 1 ], %i2 <== NOT EXECUTED
4001bcf8: b4 0e a0 03 and %i2, 3, %i2 <== NOT EXECUTED
4001bcfc: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
4001bd00: 12 bf ff f7 bne 4001bcdc <msdos_dir_read+0x4e0> <== NOT EXECUTED
4001bd04: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001bd08: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
4001bd0c: 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) {
4001bd10: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
4001bd14: 12 bf ff f6 bne 4001bcec <msdos_dir_read+0x4f0> <== NOT EXECUTED
4001bd18: 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)
4001bd1c: 94 02 a0 01 inc %o2 <== NOT EXECUTED
4001bd20: 86 02 c0 0c add %o3, %o4, %g3 <== NOT EXECUTED
4001bd24: 10 bf ff a5 b 4001bbb8 <msdos_dir_read+0x3bc> <== NOT EXECUTED
4001bd28: 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);
4001bd2c: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001bd30: 7f ff b6 01 call 40009534 <rtems_semaphore_release> <== NOT EXECUTED
4001bd34: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4001bd38: 40 00 01 96 call 4001c390 <__errno> <== NOT EXECUTED
4001bd3c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4001bd40: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001bd44: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001bd48: 81 c7 e0 08 ret <== NOT EXECUTED
4001bd4c: 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);
4001bd50: 40 00 01 90 call 4001c390 <__errno> <== NOT EXECUTED
4001bd54: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
4001bd58: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001bd5c: 10 bf ff ac b 4001bc0c <msdos_dir_read+0x410> <== NOT EXECUTED
4001bd60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001bd64 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001bd64: 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;
4001bd68: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001bd6c: 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;
4001bd70: 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,
4001bd74: 92 10 20 00 clr %o1
4001bd78: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001bd7c: 7f ff b5 9f call 400093f8 <rtems_semaphore_obtain>
4001bd80: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001bd84: 80 a2 20 00 cmp %o0, 0
4001bd88: 12 80 00 1a bne 4001bdf0 <msdos_dir_stat+0x8c> <== NEVER TAKEN
4001bd8c: 01 00 00 00 nop
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
4001bd90: 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;
4001bd94: 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);
4001bd98: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
4001bd9c: 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;
4001bda0: 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;
4001bda4: c8 07 20 40 ld [ %i4 + 0x40 ], %g4
rtems_semaphore_release(fs_info->vol_sema);
4001bda8: 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);
4001bdac: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
4001bdb0: 05 00 00 10 sethi %hi(0x4000), %g2
4001bdb4: 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;
4001bdb8: 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;
4001bdbc: f4 26 60 08 st %i2, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001bdc0: c0 26 60 18 clr [ %i1 + 0x18 ]
4001bdc4: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
4001bdc8: 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;
4001bdcc: c4 26 60 0c st %g2, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001bdd0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
4001bdd4: fa 26 60 44 st %i5, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
4001bdd8: f6 26 60 40 st %i3, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001bddc: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
4001bde0: 7f ff b5 d5 call 40009534 <rtems_semaphore_release>
4001bde4: b0 10 20 00 clr %i0
return RC_OK;
}
4001bde8: 81 c7 e0 08 ret
4001bdec: 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);
4001bdf0: 40 00 01 68 call 4001c390 <__errno> <== NOT EXECUTED
4001bdf4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001bdf8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001bdfc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001be00: 81 c7 e0 08 ret <== NOT EXECUTED
4001be04: 81 e8 00 00 restore <== NOT EXECUTED
400184bc <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
400184bc: 9d e3 bf a0 save %sp, -96, %sp
400184c0: 80 a6 e0 01 cmp %i3, 1
400184c4: 02 80 00 17 be 40018520 <msdos_eval_token+0x64>
400184c8: 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);
400184cc: 90 07 60 18 add %i5, 0x18, %o0
400184d0: 92 10 00 1a mov %i2, %o1
400184d4: 40 00 06 2e call 40019d8c <msdos_find_name>
400184d8: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
400184dc: 80 a2 20 00 cmp %o0, 0
400184e0: 12 80 00 17 bne 4001853c <msdos_eval_token+0x80>
400184e4: 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)
400184e8: 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;
400184ec: 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)
400184f0: 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;
400184f4: c0 27 60 0c clr [ %i5 + 0xc ]
400184f8: 80 a0 a0 00 cmp %g2, 0
400184fc: 12 80 00 1a bne 40018564 <msdos_eval_token+0xa8>
40018500: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
40018504: c2 00 60 94 ld [ %g1 + 0x94 ], %g1
40018508: 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)) {
4001850c: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40018510: 80 a0 00 01 cmp %g0, %g1
40018514: b0 60 3f ff subx %g0, -1, %i0
40018518: 81 c7 e0 08 ret
4001851c: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
40018520: c2 4e 80 00 ldsb [ %i2 ], %g1
40018524: 80 a0 60 2e cmp %g1, 0x2e
40018528: 12 bf ff ea bne 400184d0 <msdos_eval_token+0x14>
4001852c: 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;
40018530: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_error(ctx, 0);
}
}
return status;
}
40018534: 81 c7 e0 08 ret
40018538: 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) {
4001853c: 82 10 61 01 or %g1, 0x101, %g1
40018540: 80 a2 00 01 cmp %o0, %g1
40018544: 02 bf ff f5 be 40018518 <msdos_eval_token+0x5c> <== ALWAYS TAKEN
40018548: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
4001854c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018550: 92 10 20 00 clr %o1 <== NOT EXECUTED
40018554: 7f ff b6 19 call 40005db8 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40018558: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
4001855c: 81 c7 e0 08 ret <== NOT EXECUTED
40018560: 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;
40018564: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
40018568: 10 bf ff e9 b 4001850c <msdos_eval_token+0x50>
4001856c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
4001be64 <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)
{
4001be64: 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;
4001be68: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001be6c: 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;
4001be70: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001be74: 94 10 20 00 clr %o2
4001be78: 7f ff b5 60 call 400093f8 <rtems_semaphore_obtain>
4001be7c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001be80: 80 a2 20 00 cmp %o0, 0
4001be84: 12 80 00 09 bne 4001bea8 <msdos_file_close+0x44> <== NEVER TAKEN
4001be88: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
4001be8c: 7f ff ff df call 4001be08 <msdos_file_update>
4001be90: 90 10 00 18 mov %i0, %o0
4001be94: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
4001be98: 7f ff b5 a7 call 40009534 <rtems_semaphore_release>
4001be9c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001bea0: 81 c7 e0 08 ret
4001bea4: 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);
4001bea8: 40 00 01 3a call 4001c390 <__errno> <== NOT EXECUTED
4001beac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001beb0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001beb4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001beb8: 81 c7 e0 08 ret <== NOT EXECUTED
4001bebc: 81 e8 00 00 restore <== NOT EXECUTED
4001c0c8 <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)
{
4001c0c8: 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;
4001c0cc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001c0d0: 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;
4001c0d4: 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,
4001c0d8: 92 10 20 00 clr %o1
4001c0dc: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001c0e0: 7f ff b4 c6 call 400093f8 <rtems_semaphore_obtain>
4001c0e4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001c0e8: 80 a2 20 00 cmp %o0, 0
4001c0ec: 12 80 00 31 bne 4001c1b0 <msdos_file_ftruncate+0xe8> <== NEVER TAKEN
4001c0f0: 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) {
4001c0f4: 14 80 00 1f bg 4001c170 <msdos_file_ftruncate+0xa8> <== NEVER TAKEN
4001c0f8: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
4001c0fc: 80 a2 00 19 cmp %o0, %i1
4001c100: 12 80 00 06 bne 4001c118 <msdos_file_ftruncate+0x50> <== NEVER TAKEN
4001c104: 90 10 00 1d mov %i5, %o0
4001c108: 80 a6 c0 1a cmp %i3, %i2
4001c10c: 18 80 00 1b bgu 4001c178 <msdos_file_ftruncate+0xb0>
4001c110: 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,
4001c114: 90 10 00 1d mov %i5, %o0
4001c118: 92 10 00 1c mov %i4, %o1
4001c11c: 94 10 20 01 mov 1, %o2
4001c120: 96 10 00 1a mov %i2, %o3
4001c124: 7f ff da be call 40012c1c <fat_file_extend>
4001c128: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
4001c12c: b0 92 20 00 orcc %o0, 0, %i0
4001c130: 12 80 00 17 bne 4001c18c <msdos_file_ftruncate+0xc4> <== NEVER TAKEN
4001c134: 80 a6 00 19 cmp %i0, %i1
4001c138: 02 80 00 19 be 4001c19c <msdos_file_ftruncate+0xd4> <== ALWAYS TAKEN
4001c13c: c2 07 bf fc ld [ %fp + -4 ], %g1
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
4001c140: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001c144: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001c148: 7f ff da 11 call 4001298c <fat_file_truncate> <== NOT EXECUTED
4001c14c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
4001c150: 40 00 00 90 call 4001c390 <__errno> <== NOT EXECUTED
4001c154: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001c158: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
4001c15c: 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);
4001c160: 7f ff b4 f5 call 40009534 <rtems_semaphore_release> <== NOT EXECUTED
4001c164: d0 07 60 9c ld [ %i5 + 0x9c ], %o0 <== NOT EXECUTED
return rc;
}
4001c168: 81 c7 e0 08 ret <== NOT EXECUTED
4001c16c: 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);
4001c170: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c174: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001c178: 7f ff da 05 call 4001298c <fat_file_truncate>
4001c17c: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
4001c180: b0 92 20 00 orcc %o0, 0, %i0
4001c184: 22 80 00 02 be,a 4001c18c <msdos_file_ftruncate+0xc4> <== ALWAYS TAKEN
4001c188: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_fd->fat_file_size = length;
}
rtems_semaphore_release(fs_info->vol_sema);
4001c18c: 7f ff b4 ea call 40009534 <rtems_semaphore_release>
4001c190: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001c194: 81 c7 e0 08 ret
4001c198: 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) {
4001c19c: 80 a0 40 1a cmp %g1, %i2
4001c1a0: 12 bf ff e9 bne 4001c144 <msdos_file_ftruncate+0x7c> <== NEVER TAKEN
4001c1a4: 92 10 00 1c mov %i4, %o1
rc = -1;
}
}
if (rc == RC_OK) {
fat_fd->fat_file_size = length;
4001c1a8: 10 bf ff f9 b 4001c18c <msdos_file_ftruncate+0xc4>
4001c1ac: 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);
4001c1b0: 40 00 00 78 call 4001c390 <__errno> <== NOT EXECUTED
4001c1b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001c1b8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001c1bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001c1c0: 81 c7 e0 08 ret <== NOT EXECUTED
4001c1c4: 81 e8 00 00 restore <== NOT EXECUTED
4001bec0 <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)
{
4001bec0: 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;
4001bec4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001bec8: 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;
4001becc: 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,
4001bed0: 92 10 20 00 clr %o1
4001bed4: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001bed8: 7f ff b5 48 call 400093f8 <rtems_semaphore_obtain>
4001bedc: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001bee0: 80 a2 20 00 cmp %o0, 0
4001bee4: 12 80 00 12 bne 4001bf2c <msdos_file_read+0x6c> <== NEVER TAKEN
4001bee8: 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,
4001beec: d4 06 20 0c ld [ %i0 + 0xc ], %o2
4001bef0: 90 10 00 10 mov %l0, %o0
4001bef4: 92 10 00 1d mov %i5, %o1
4001bef8: 7f ff da 20 call 40012778 <fat_file_read>
4001befc: 96 10 00 1a mov %i2, %o3
buffer);
if (ret > 0)
4001bf00: b2 92 20 00 orcc %o0, 0, %i1
4001bf04: 04 80 00 06 ble 4001bf1c <msdos_file_read+0x5c>
4001bf08: 85 3e 60 1f sra %i1, 0x1f, %g2
iop->offset += ret;
4001bf0c: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
4001bf10: b6 87 40 19 addcc %i5, %i1, %i3
4001bf14: b4 47 00 02 addx %i4, %g2, %i2
4001bf18: f4 3e 20 08 std %i2, [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
4001bf1c: 7f ff b5 86 call 40009534 <rtems_semaphore_release>
4001bf20: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001bf24: 81 c7 e0 08 ret
4001bf28: 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);
4001bf2c: 40 00 01 19 call 4001c390 <__errno> <== NOT EXECUTED
4001bf30: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001bf34: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001bf38: 10 bf ff fb b 4001bf24 <msdos_file_read+0x64> <== NOT EXECUTED
4001bf3c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001c018 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001c018: 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;
4001c01c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001c020: 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;
4001c024: 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,
4001c028: 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;
4001c02c: f6 17 60 06 lduh [ %i5 + 6 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001c030: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001c034: 94 10 20 00 clr %o2
4001c038: 7f ff b4 f0 call 400093f8 <rtems_semaphore_obtain>
4001c03c: b6 06 ff ff add %i3, -1, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001c040: 80 a2 20 00 cmp %o0, 0
4001c044: 12 80 00 1b bne 4001c0b0 <msdos_file_stat+0x98> <== NEVER TAKEN
4001c048: 01 00 00 00 nop
4001c04c: 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;
4001c050: 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);
4001c054: 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;
4001c058: 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;
4001c05c: 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;
4001c060: c8 07 20 40 ld [ %i4 + 0x40 ], %g4
rtems_semaphore_release(fs_info->vol_sema);
4001c064: 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);
4001c068: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
4001c06c: 05 00 00 20 sethi %hi(0x8000), %g2
4001c070: 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)
4001c074: 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;
4001c078: 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)
4001c07c: 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;
4001c080: 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;
4001c084: 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;
4001c088: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
4001c08c: 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;
4001c090: c4 26 60 0c st %g2, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001c094: 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;
4001c098: f4 3e 60 40 std %i2, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001c09c: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
4001c0a0: 7f ff b5 25 call 40009534 <rtems_semaphore_release>
4001c0a4: b0 10 20 00 clr %i0
return RC_OK;
}
4001c0a8: 81 c7 e0 08 ret
4001c0ac: 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);
4001c0b0: 40 00 00 b8 call 4001c390 <__errno> <== NOT EXECUTED
4001c0b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001c0b8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001c0bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001c0c0: 81 c7 e0 08 ret <== NOT EXECUTED
4001c0c4: 81 e8 00 00 restore <== NOT EXECUTED
4001c1c8 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
4001c1c8: 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;
4001c1cc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001c1d0: 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;
4001c1d4: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001c1d8: 94 10 20 00 clr %o2
4001c1dc: 7f ff b4 87 call 400093f8 <rtems_semaphore_obtain>
4001c1e0: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001c1e4: 80 a2 20 00 cmp %o0, 0
4001c1e8: 12 80 00 0d bne 4001c21c <msdos_file_sync+0x54> <== NEVER TAKEN
4001c1ec: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
4001c1f0: 7f ff ff 06 call 4001be08 <msdos_file_update>
4001c1f4: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4001c1f8: b0 92 20 00 orcc %o0, 0, %i0
4001c1fc: 12 80 00 04 bne 4001c20c <msdos_file_sync+0x44> <== NEVER TAKEN
4001c200: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
4001c204: 7f ff df c8 call 40014124 <fat_sync>
4001c208: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
4001c20c: 7f ff b4 ca call 40009534 <rtems_semaphore_release>
4001c210: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return RC_OK;
}
4001c214: 81 c7 e0 08 ret
4001c218: 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);
4001c21c: 40 00 00 5d call 4001c390 <__errno> <== NOT EXECUTED
4001c220: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001c224: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001c228: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001c22c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c230: 81 e8 00 00 restore <== NOT EXECUTED
4001be08 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
4001be08: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001be0c: 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))
4001be10: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4001be14: 80 88 60 01 btst 1, %g1
4001be18: 02 80 00 04 be 4001be28 <msdos_file_update+0x20> <== ALWAYS TAKEN
4001be1c: 90 10 20 00 clr %o0
return rc;
}
}
return rc;
}
4001be20: 81 c7 e0 08 ret <== NOT EXECUTED
4001be24: 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);
4001be28: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001be2c: 7f ff f2 bf call 40018928 <msdos_set_first_cluster_num>
4001be30: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001be34: 80 a2 20 00 cmp %o0, 0
4001be38: 12 bf ff fa bne 4001be20 <msdos_file_update+0x18> <== NEVER TAKEN
4001be3c: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
4001be40: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001be44: 7f ff f2 f4 call 40018a14 <msdos_set_file_size>
4001be48: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001be4c: 80 a2 20 00 cmp %o0, 0
4001be50: 12 bf ff f4 bne 4001be20 <msdos_file_update+0x18> <== NEVER TAKEN
4001be54: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
4001be58: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
4001be5c: 7f ff f2 6e call 40018814 <msdos_set_dir_wrt_time_and_date>
4001be60: 81 e8 00 00 restore
4001bf40 <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)
{
4001bf40: 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;
4001bf44: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001bf48: 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;
4001bf4c: 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,
4001bf50: 92 10 20 00 clr %o1
4001bf54: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001bf58: 7f ff b5 28 call 400093f8 <rtems_semaphore_obtain>
4001bf5c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001bf60: 80 a2 20 00 cmp %o0, 0
4001bf64: 12 80 00 24 bne 4001bff4 <msdos_file_write+0xb4> <== NEVER TAKEN
4001bf68: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
4001bf6c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001bf70: 80 88 62 00 btst 0x200, %g1
4001bf74: 32 80 00 1b bne,a 4001bfe0 <msdos_file_write+0xa0>
4001bf78: d4 04 60 18 ld [ %l1 + 0x18 ], %o2
4001bf7c: 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,
4001bf80: 98 10 00 19 mov %i1, %o4
4001bf84: 90 10 00 10 mov %l0, %o0
4001bf88: 92 10 00 11 mov %l1, %o1
4001bf8c: 7f ff db b9 call 40012e70 <fat_file_write>
4001bf90: 96 10 00 1a mov %i2, %o3
buffer);
if (ret < 0)
4001bf94: b2 92 20 00 orcc %o0, 0, %i1
4001bf98: 06 80 00 1c bl 4001c008 <msdos_file_write+0xc8> <== NEVER TAKEN
4001bf9c: 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;
4001bfa0: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
4001bfa4: 86 86 40 1b addcc %i1, %i3, %g3
4001bfa8: 84 47 00 1a addx %i4, %i2, %g2
4001bfac: c4 3e 20 08 std %g2, [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
4001bfb0: 80 a0 a0 00 cmp %g2, 0
4001bfb4: 14 80 00 0e bg 4001bfec <msdos_file_write+0xac> <== NEVER TAKEN
4001bfb8: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
4001bfbc: 80 a0 a0 00 cmp %g2, 0
4001bfc0: 12 80 00 04 bne 4001bfd0 <msdos_file_write+0x90> <== NEVER TAKEN
4001bfc4: 80 a0 c0 01 cmp %g3, %g1
4001bfc8: 38 80 00 02 bgu,a 4001bfd0 <msdos_file_write+0x90>
4001bfcc: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
fat_fd->fat_file_size = iop->offset;
rtems_semaphore_release(fs_info->vol_sema);
4001bfd0: 7f ff b5 59 call 40009534 <rtems_semaphore_release>
4001bfd4: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001bfd8: 81 c7 e0 08 ret
4001bfdc: 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;
4001bfe0: c0 26 20 08 clr [ %i0 + 8 ]
4001bfe4: 10 bf ff e7 b 4001bf80 <msdos_file_write+0x40>
4001bfe8: 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;
4001bfec: 10 bf ff f9 b 4001bfd0 <msdos_file_write+0x90> <== NOT EXECUTED
4001bff0: 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);
4001bff4: 40 00 00 e7 call 4001c390 <__errno> <== NOT EXECUTED
4001bff8: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001bffc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001c000: 10 bf ff f6 b 4001bfd8 <msdos_file_write+0x98> <== NOT EXECUTED
4001c004: 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);
4001c008: d0 04 20 9c ld [ %l0 + 0x9c ], %o0 <== NOT EXECUTED
4001c00c: 7f ff b5 4a call 40009534 <rtems_semaphore_release> <== NOT EXECUTED
4001c010: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
return -1;
4001c014: 30 bf ff f1 b,a 4001bfd8 <msdos_file_write+0x98> <== NOT EXECUTED
4001b5f8 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
4001b5f8: 82 10 20 00 clr %g1
dn[i] = ' ';
4001b5fc: 84 10 20 20 mov 0x20, %g2
4001b600: 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++)
4001b604: 82 00 60 01 inc %g1
4001b608: 80 a0 60 0b cmp %g1, 0xb
4001b60c: 32 bf ff fe bne,a 4001b604 <msdos_filename_unix2dos+0xc>
4001b610: 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) {
4001b614: c2 4a 00 00 ldsb [ %o0 ], %g1
4001b618: 80 a0 60 2e cmp %g1, 0x2e
4001b61c: 02 80 00 5f be 4001b798 <msdos_filename_unix2dos+0x1a0> <== NEVER TAKEN
4001b620: c4 0a 00 00 ldub [ %o0 ], %g2
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
4001b624: 80 a2 60 00 cmp %o1, 0
4001b628: 02 80 00 5a be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b62c: 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++) {
4001b630: 82 88 a0 ff andcc %g2, 0xff, %g1
4001b634: 02 80 00 57 be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b638: 09 10 00 b4 sethi %hi(0x4002d000), %g4
if (msdos_map[c] == 0)
4001b63c: 88 11 22 20 or %g4, 0x220, %g4 ! 4002d220 <msdos_map>
4001b640: c4 09 00 01 ldub [ %g4 + %g1 ], %g2
4001b644: 80 88 a0 ff btst 0xff, %g2
4001b648: 02 80 00 22 be 4001b6d0 <msdos_filename_unix2dos+0xd8>
4001b64c: 86 10 00 08 mov %o0, %g3
4001b650: 10 80 00 0f b 4001b68c <msdos_filename_unix2dos+0x94>
4001b654: 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++) {
4001b658: 02 80 00 18 be 4001b6b8 <msdos_filename_unix2dos+0xc0>
4001b65c: 01 00 00 00 nop
4001b660: c4 08 c0 00 ldub [ %g3 ], %g2
4001b664: 80 a0 a0 00 cmp %g2, 0
4001b668: 02 80 00 16 be 4001b6c0 <msdos_filename_unix2dos+0xc8> <== NEVER TAKEN
4001b66c: 80 a0 a0 2e cmp %g2, 0x2e
4001b670: 22 80 00 15 be,a 4001b6c4 <msdos_filename_unix2dos+0xcc>
4001b674: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
if (msdos_map[c] == 0)
4001b678: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
4001b67c: 80 88 a0 ff btst 0xff, %g2
4001b680: 22 80 00 11 be,a 4001b6c4 <msdos_filename_unix2dos+0xcc>
4001b684: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
break;
dn[i] = msdos_map[c];
un++;
4001b688: 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];
4001b68c: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
4001b690: 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++) {
4001b694: 82 00 60 01 inc %g1
4001b698: 84 10 20 01 mov 1, %g2
4001b69c: 80 a0 60 07 cmp %g1, 7
4001b6a0: 04 80 00 03 ble 4001b6ac <msdos_filename_unix2dos+0xb4>
4001b6a4: 92 02 7f ff add %o1, -1, %o1
4001b6a8: 84 10 20 00 clr %g2
4001b6ac: 80 88 a0 ff btst 0xff, %g2
4001b6b0: 12 bf ff ea bne 4001b658 <msdos_filename_unix2dos+0x60>
4001b6b4: 80 a2 60 00 cmp %o1, 0
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
4001b6b8: 02 80 00 36 be 4001b790 <msdos_filename_unix2dos+0x198>
4001b6bc: 01 00 00 00 nop
4001b6c0: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
4001b6c4: 80 a0 60 00 cmp %g1, 0
4001b6c8: 02 80 00 32 be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b6cc: 01 00 00 00 nop
un++;
4001b6d0: 86 00 e0 01 inc %g3
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
4001b6d4: 80 a0 60 2e cmp %g1, 0x2e
4001b6d8: 02 80 00 0c be 4001b708 <msdos_filename_unix2dos+0x110>
4001b6dc: 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)) {
4001b6e0: 80 a2 60 00 cmp %o1, 0
4001b6e4: 02 80 00 2b be 4001b790 <msdos_filename_unix2dos+0x198>
4001b6e8: 01 00 00 00 nop
4001b6ec: c2 08 c0 00 ldub [ %g3 ], %g1
4001b6f0: 80 a0 60 00 cmp %g1, 0
4001b6f4: 02 80 00 27 be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b6f8: 92 02 7f ff add %o1, -1, %o1
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
4001b6fc: 80 a0 60 2e cmp %g1, 0x2e
4001b700: 12 bf ff f8 bne 4001b6e0 <msdos_filename_unix2dos+0xe8> <== ALWAYS TAKEN
4001b704: 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++) {
4001b708: 80 a2 60 00 cmp %o1, 0
4001b70c: 02 80 00 21 be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b710: 01 00 00 00 nop
4001b714: c2 08 c0 00 ldub [ %g3 ], %g1
4001b718: 80 a0 60 00 cmp %g1, 0
4001b71c: 02 80 00 1d be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b720: 01 00 00 00 nop
if (msdos_map[c] == 0)
4001b724: c4 09 00 01 ldub [ %g4 + %g1 ], %g2
4001b728: 80 88 a0 ff btst 0xff, %g2
4001b72c: 02 80 00 19 be 4001b790 <msdos_filename_unix2dos+0x198>
4001b730: 82 10 20 08 mov 8, %g1
break;
dn[i] = msdos_map[c];
4001b734: 10 80 00 0d b 4001b768 <msdos_filename_unix2dos+0x170>
4001b738: 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++) {
4001b73c: 02 80 00 15 be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b740: 01 00 00 00 nop
4001b744: c4 0b 7f f8 ldub [ %o5 + -8 ], %g2
4001b748: 80 a0 a0 00 cmp %g2, 0
4001b74c: 02 80 00 11 be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b750: 01 00 00 00 nop
if (msdos_map[c] == 0)
4001b754: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
4001b758: 80 88 a0 ff btst 0xff, %g2
4001b75c: 02 80 00 0d be 4001b790 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001b760: 01 00 00 00 nop
break;
dn[i] = msdos_map[c];
4001b764: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
unlen--;
4001b768: 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++) {
4001b76c: 82 00 60 01 inc %g1
4001b770: 84 10 20 01 mov 1, %g2
4001b774: 80 a0 60 0a cmp %g1, 0xa
4001b778: 04 80 00 03 ble 4001b784 <msdos_filename_unix2dos+0x18c>
4001b77c: 9a 00 c0 01 add %g3, %g1, %o5
4001b780: 84 10 20 00 clr %g2
4001b784: 80 88 a0 ff btst 0xff, %g2
4001b788: 12 bf ff ed bne 4001b73c <msdos_filename_unix2dos+0x144>
4001b78c: 80 a2 60 00 cmp %o1, 0
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
4001b790: 81 c3 e0 08 retl
4001b794: 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) {
4001b798: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
4001b79c: 22 bf ff fd be,a 4001b790 <msdos_filename_unix2dos+0x198><== NOT EXECUTED
4001b7a0: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
4001b7a4: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
4001b7a8: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
4001b7ac: 12 80 00 05 bne 4001b7c0 <msdos_filename_unix2dos+0x1c8> <== NOT EXECUTED
4001b7b0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4001b7b4: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
4001b7b8: 02 80 00 0e be 4001b7f0 <msdos_filename_unix2dos+0x1f8> <== NOT EXECUTED
4001b7bc: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
4001b7c0: 32 80 00 08 bne,a 4001b7e0 <msdos_filename_unix2dos+0x1e8><== NOT EXECUTED
4001b7c4: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
4001b7c8: 30 bf ff f2 b,a 4001b790 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
4001b7cc: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED
4001b7d0: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
4001b7d4: 12 bf ff 97 bne 4001b630 <msdos_filename_unix2dos+0x38> <== NOT EXECUTED
4001b7d8: c4 0a 00 00 ldub [ %o0 ], %g2 <== NOT EXECUTED
4001b7dc: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
4001b7e0: 12 bf ff fb bne 4001b7cc <msdos_filename_unix2dos+0x1d4> <== NOT EXECUTED
4001b7e4: 90 02 20 01 inc %o0 <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
4001b7e8: 81 c3 e0 08 retl <== NOT EXECUTED
4001b7ec: 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] = '.';
4001b7f0: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
4001b7f4: 10 bf ff e7 b 4001b790 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
4001b7f8: c2 2a a0 01 stb %g1, [ %o2 + 1 ] <== NOT EXECUTED
40019d8c <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
40019d8c: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40019d90: 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);
40019d94: 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;
40019d98: 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,
40019d9c: 94 10 00 1d mov %i5, %o2
40019da0: 92 10 00 1a mov %i2, %o1
40019da4: 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;
40019da8: 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);
40019dac: c0 27 bf e0 clr [ %fp + -32 ]
40019db0: c0 27 bf e4 clr [ %fp + -28 ]
40019db4: c0 27 bf e8 clr [ %fp + -24 ]
40019db8: c0 27 bf ec clr [ %fp + -20 ]
40019dbc: c0 27 bf f0 clr [ %fp + -16 ]
40019dc0: c0 27 bf f4 clr [ %fp + -12 ]
40019dc4: c0 27 bf f8 clr [ %fp + -8 ]
40019dc8: c0 27 bf fc clr [ %fp + -4 ]
name_type = msdos_long_to_short (name,
40019dcc: 7f ff fa 04 call 400185dc <msdos_long_to_short>
40019dd0: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
40019dd4: 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,
40019dd8: 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,
40019ddc: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40019de0: 90 10 00 18 mov %i0, %o0
40019de4: 92 10 20 00 clr %o1
40019de8: 94 10 00 19 mov %i1, %o2
40019dec: 96 10 00 1a mov %i2, %o3
40019df0: 7f ff ff a6 call 40019c88 <msdos_get_name_node>
40019df4: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
40019df8: b0 92 20 00 orcc %o0, 0, %i0
40019dfc: 12 80 00 23 bne 40019e88 <msdos_find_name+0xfc>
40019e00: 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;
40019e04: 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) ||
40019e08: 84 08 60 08 and %g1, 8, %g2
40019e0c: 80 88 a0 ff btst 0xff, %g2
40019e10: 12 80 00 1e bne 40019e88 <msdos_find_name+0xfc> <== NEVER TAKEN
40019e14: b0 16 21 01 or %i0, 0x101, %i0
40019e18: 82 08 60 3f and %g1, 0x3f, %g1
40019e1c: 80 a0 60 0f cmp %g1, 0xf
40019e20: 02 80 00 1a be 40019e88 <msdos_find_name+0xfc> <== NEVER TAKEN
40019e24: 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);
40019e28: 92 07 bf d0 add %fp, -48, %o1
40019e2c: 7f ff e1 9f call 400124a8 <fat_file_open>
40019e30: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
40019e34: b0 92 20 00 orcc %o0, 0, %i0
40019e38: 12 80 00 14 bne 40019e88 <msdos_find_name+0xfc> <== NEVER TAKEN
40019e3c: fa 07 bf cc ld [ %fp + -52 ], %i5
return rc;
fat_fd->dir_pos = dir_pos;
40019e40: 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)
40019e44: 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;
40019e48: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
40019e4c: 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)
40019e50: 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;
40019e54: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
40019e58: c4 07 bf d8 ld [ %fp + -40 ], %g2
40019e5c: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
40019e60: 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)
40019e64: 02 80 00 0b be 40019e90 <msdos_find_name+0x104>
40019e68: 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);
40019e6c: d2 07 20 08 ld [ %i4 + 8 ], %o1
40019e70: 7f ff e3 08 call 40012a90 <fat_file_close>
40019e74: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
40019e78: b0 92 20 00 orcc %o0, 0, %i0
40019e7c: 12 80 00 45 bne 40019f90 <msdos_find_name+0x204> <== NEVER TAKEN
40019e80: 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;
40019e84: c2 27 20 08 st %g1, [ %i4 + 8 ]
return rc;
}
40019e88: 81 c7 e0 08 ret
40019e8c: 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));
40019e90: 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);
40019e94: c8 17 bf f4 lduh [ %fp + -12 ], %g4
40019e98: 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));
40019e9c: c4 17 bf f8 lduh [ %fp + -8 ], %g2
40019ea0: 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);
40019ea4: 89 29 20 10 sll %g4, 0x10, %g4
40019ea8: 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));
40019eac: 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);
40019eb0: b1 31 20 18 srl %g4, 0x18, %i0
40019eb4: 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));
40019eb8: 91 30 a0 18 srl %g2, 0x18, %o0
40019ebc: 93 30 60 18 srl %g1, 0x18, %o1
40019ec0: 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);
40019ec4: 89 31 20 08 srl %g4, 8, %g4
40019ec8: 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));
40019ecc: 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);
40019ed0: 03 00 00 3f sethi %hi(0xfc00), %g1
40019ed4: 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));
40019ed8: 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);
40019edc: 88 09 00 01 and %g4, %g1, %g4
40019ee0: 86 08 c0 01 and %g3, %g1, %g3
40019ee4: 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));
40019ee8: 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);
40019eec: 89 29 20 10 sll %g4, 0x10, %g4
40019ef0: 86 16 40 03 or %i1, %g3, %g3
40019ef4: 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));
40019ef8: 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);
40019efc: 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));
40019f00: 40 00 05 70 call 4001b4c0 <msdos_date_dos2unix>
40019f04: 90 12 00 02 or %o0, %g2, %o0
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
40019f08: c2 0f bf eb ldub [ %fp + -21 ], %g1
40019f0c: 82 08 60 10 and %g1, 0x10, %g1
40019f10: 80 88 60 ff btst 0xff, %g1
40019f14: 12 80 00 27 bne 40019fb0 <msdos_find_name+0x224>
40019f18: 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));
40019f1c: c4 07 bf fc ld [ %fp + -4 ], %g2
40019f20: c2 07 bf cc ld [ %fp + -52 ], %g1
40019f24: bb 28 a0 18 sll %g2, 0x18, %i5
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
40019f28: 89 30 a0 18 srl %g2, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
40019f2c: 87 30 a0 08 srl %g2, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40019f30: 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;
40019f34: 86 08 e0 ff and %g3, 0xff, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40019f38: 87 28 e0 10 sll %g3, 0x10, %g3
40019f3c: 86 11 00 03 or %g4, %g3, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40019f40: 85 30 a0 10 srl %g2, 0x10, %g2
40019f44: 84 08 a0 ff and %g2, 0xff, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40019f48: 85 28 a0 08 sll %g2, 8, %g2
40019f4c: 84 10 c0 02 or %g3, %g2, %g2
fat_fd->fat_file_type = FAT_FILE;
40019f50: 86 10 20 04 mov 4, %g3
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
40019f54: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
40019f58: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
40019f5c: 86 10 3f ff mov -1, %g3
40019f60: 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;
40019f64: 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;
40019f68: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
40019f6c: 80 a0 a0 00 cmp %g2, 0
40019f70: 02 80 00 0d be 40019fa4 <msdos_find_name+0x218>
40019f74: c6 20 60 38 st %g3, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
40019f78: 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) &&
40019f7c: 80 a1 00 02 cmp %g4, %g2
40019f80: 0a 80 00 0a bcs 40019fa8 <msdos_find_name+0x21c>
40019f84: 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;
40019f88: 10 bf ff b9 b 40019e6c <msdos_find_name+0xe0>
40019f8c: 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);
40019f90: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
40019f94: 7f ff e2 bf call 40012a90 <fat_file_close> <== NOT EXECUTED
40019f98: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40019f9c: 81 c7 e0 08 ret <== NOT EXECUTED
40019fa0: 81 e8 00 00 restore <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
40019fa4: 84 10 3f ff mov -1, %g2
40019fa8: 10 bf ff b1 b 40019e6c <msdos_find_name+0xe0>
40019fac: 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;
40019fb0: d2 07 bf cc ld [ %fp + -52 ], %o1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40019fb4: 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;
40019fb8: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40019fbc: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
40019fc0: 7f ff e4 70 call 40013180 <fat_file_size>
40019fc4: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
40019fc8: b0 92 20 00 orcc %o0, 0, %i0
40019fcc: 12 bf ff f1 bne 40019f90 <msdos_find_name+0x204> <== NEVER TAKEN
40019fd0: c2 07 bf cc ld [ %fp + -52 ], %g1
40019fd4: 10 bf ff e4 b 40019f64 <msdos_find_name+0x1d8>
40019fd8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40018dbc <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
)
{
40018dbc: 9d e3 bf 80 save %sp, -128, %sp
40018dc0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40018dc4: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
40018dc8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40018dcc: 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);
40018dd0: 80 a7 20 00 cmp %i4, 0
40018dd4: 04 80 02 80 ble 400197d4 <msdos_find_name_in_fat_file+0xa18><== NEVER TAKEN
40018dd8: 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))
40018ddc: c4 07 a0 58 ld [ %fp + 0x58 ], %g2
40018de0: 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;
40018de4: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
40018de8: 80 a0 00 01 cmp %g0, %g1
40018dec: c0 20 80 00 clr [ %g2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40018df0: 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;
40018df4: c0 20 a0 04 clr [ %g2 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40018df8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40018dfc: 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;
40018e00: 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))
40018e04: b2 60 3f ff subx %g0, -1, %i1
40018e08: 80 a6 60 00 cmp %i1, 0
40018e0c: 02 80 00 82 be 40019014 <msdos_find_name_in_fat_file+0x258>
40018e10: c2 27 bf f8 st %g1, [ %fp + -8 ]
40018e14: 80 a6 a0 00 cmp %i2, 0
40018e18: 02 80 00 7f be 40019014 <msdos_find_name_in_fat_file+0x258>
40018e1c: 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) &&
40018e20: c4 07 a0 48 ld [ %fp + 0x48 ], %g2
40018e24: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
40018e28: 80 a0 60 01 cmp %g1, 1
40018e2c: 22 80 01 85 be,a 40019440 <msdos_find_name_in_fat_file+0x684>
40018e30: 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;
40018e34: 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))
40018e38: 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;
40018e3c: 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;
40018e40: 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))
40018e44: 82 00 60 01 inc %g1
40018e48: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
40018e4c: 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),
40018e50: c0 27 bf e8 clr [ %fp + -24 ]
40018e54: 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;
40018e58: a6 10 20 00 clr %l3
40018e5c: 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;
40018e60: a0 10 20 00 clr %l0
40018e64: 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;
40018e68: a4 10 20 00 clr %l2
40018e6c: 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;
40018e70: 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;
40018e74: 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;
40018e78: a8 10 20 00 clr %l4
40018e7c: 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),
40018e80: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
40018e84: d4 07 bf e8 ld [ %fp + -24 ], %o2
40018e88: 90 10 00 1c mov %i4, %o0
40018e8c: 7f ff e6 3b call 40012778 <fat_file_read>
40018e90: 96 10 00 11 mov %l1, %o3
40018e94: 80 a2 20 00 cmp %o0, 0
40018e98: 02 80 00 e4 be 40019228 <msdos_find_name_in_fat_file+0x46c>
40018e9c: 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)
40018ea0: 04 80 01 85 ble 400194b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
40018ea4: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
40018ea8: 12 80 02 53 bne 400197f4 <msdos_find_name_in_fat_file+0xa38><== NEVER TAKEN
40018eac: 84 10 00 18 mov %i0, %g2
40018eb0: d8 07 20 a0 ld [ %i4 + 0xa0 ], %o4
40018eb4: b6 10 20 00 clr %i3
40018eb8: b0 10 00 19 mov %i1, %i0
40018ebc: ba 10 00 0c mov %o4, %i5
40018ec0: 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)
40018ec4: 80 a4 20 00 cmp %l0, 0
40018ec8: 12 80 00 04 bne 40018ed8 <msdos_find_name_in_fat_file+0x11c>
40018ecc: c6 0f 40 00 ldub [ %i5 ], %g3
40018ed0: a4 10 00 1b mov %i3, %l2
40018ed4: ae 10 00 14 mov %l4, %l7
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
40018ed8: 82 88 e0 ff andcc %g3, 0xff, %g1
40018edc: 02 80 00 e2 be 40019264 <msdos_find_name_in_fat_file+0x4a8>
40018ee0: 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)
40018ee4: 02 80 00 69 be 40019088 <msdos_find_name_in_fat_file+0x2cc>
40018ee8: 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)
40018eec: 80 88 60 ff btst 0xff, %g1
40018ef0: 02 80 00 07 be 40018f0c <msdos_find_name_in_fat_file+0x150><== NEVER TAKEN
40018ef4: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
40018ef8: 80 a6 a0 00 cmp %i2, 0
40018efc: 02 80 00 04 be 40018f0c <msdos_find_name_in_fat_file+0x150>
40018f00: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
40018f04: 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;
40018f08: 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) ==
40018f0c: 82 08 60 3f and %g1, 0x3f, %g1
40018f10: 80 a0 60 0f cmp %g1, 0xf
40018f14: 02 80 00 67 be 400190b0 <msdos_find_name_in_fat_file+0x2f4>
40018f18: 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)
40018f1c: 02 80 00 4a be 40019044 <msdos_find_name_in_fat_file+0x288>
40018f20: 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(
40018f24: 9e 07 60 0a add %i5, 0xa, %o7
40018f28: 84 10 00 1d mov %i5, %g2
40018f2c: 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;
40018f30: 10 80 00 09 b 40018f54 <msdos_find_name_in_fat_file+0x198>
40018f34: 82 10 20 00 clr %g1
40018f38: 82 08 60 01 and %g1, 1, %g1
40018f3c: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
40018f40: 80 a0 00 01 cmp %g0, %g1
40018f44: 84 00 a0 01 inc %g2
40018f48: 82 40 3f ff addx %g0, -1, %g1
40018f4c: 82 08 60 80 and %g1, 0x80, %g1
40018f50: 82 00 7f 80 add %g1, -128, %g1
40018f54: 88 09 20 ff and %g4, 0xff, %g4
40018f58: 89 31 20 01 srl %g4, 1, %g4
40018f5c: 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++)
40018f60: 80 a0 80 0f cmp %g2, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
40018f64: 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++)
40018f68: 12 bf ff f4 bne 40018f38 <msdos_find_name_in_fat_file+0x17c>
40018f6c: 88 10 00 01 mov %g1, %g4
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
40018f70: 88 1d 80 04 xor %l6, %g4, %g4
40018f74: 80 89 20 ff btst 0xff, %g4
40018f78: 12 80 00 33 bne 40019044 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
40018f7c: 80 a5 60 00 cmp %l5, 0
40018f80: 80 a6 20 00 cmp %i0, 0
40018f84: 12 80 00 30 bne 40019044 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
40018f88: 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,
40018f8c: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
40018f90: d6 07 bf e8 ld [ %fp + -24 ], %o3
40018f94: d8 07 a0 5c ld [ %fp + 0x5c ], %o4
40018f98: 90 10 00 1c mov %i4, %o0
40018f9c: 7f ff e6 eb call 40012b48 <fat_file_ioctl>
40018fa0: 94 10 20 01 mov 1, %o2
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
40018fa4: b0 92 20 00 orcc %o0, 0, %i0
40018fa8: 12 80 00 19 bne 4001900c <msdos_find_name_in_fat_file+0x250><== NEVER TAKEN
40018fac: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
40018fb0: d2 07 bf f8 ld [ %fp + -8 ], %o1
40018fb4: 80 a2 7f ff cmp %o1, -1
40018fb8: 02 80 01 34 be 40019488 <msdos_find_name_in_fat_file+0x6cc>
40018fbc: f6 20 60 04 st %i3, [ %g1 + 4 ]
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40018fc0: 7f ff a5 73 call 4000258c <.umul>
40018fc4: 90 10 00 11 mov %l1, %o0
40018fc8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
40018fcc: 96 10 00 08 mov %o0, %o3
40018fd0: 94 10 20 01 mov 1, %o2
40018fd4: 90 10 00 1c mov %i4, %o0
40018fd8: 7f ff e6 dc call 40012b48 <fat_file_ioctl>
40018fdc: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
40018fe0: 80 a2 20 00 cmp %o0, 0
40018fe4: 12 80 01 27 bne 40019480 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
40018fe8: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40018fec: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
40018ff0: d0 07 a0 60 ld [ %fp + 0x60 ], %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40018ff4: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
40018ff8: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
40018ffc: 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;
40019000: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
memcpy(name_dir_entry, entry,
40019004: 40 00 0f 88 call 4001ce24 <memcpy>
40019008: 94 10 20 20 mov 0x20, %o2
4001900c: 81 c7 e0 08 ret
40019010: 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 =
40019014: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
40019018: 92 10 20 0d mov 0xd, %o1
4001901c: 7f ff a5 98 call 4000267c <.div>
40019020: 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) &&
40019024: 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 =
40019028: 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) &&
4001902c: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
40019030: 80 a0 60 01 cmp %g1, 1
40019034: 32 bf ff 81 bne,a 40018e38 <msdos_find_name_in_fat_file+0x7c>
40019038: e2 15 60 06 lduh [ %l5 + 6 ], %l1
4001903c: 10 80 01 01 b 40019440 <msdos_find_name_in_fat_file+0x684>
40019040: 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 ||
40019044: 12 80 00 5f bne 400191c0 <msdos_find_name_in_fat_file+0x404>
40019048: 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;
4001904c: 82 10 3f ff mov -1, %g1
lfn_matched = false;
40019050: 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;
40019054: c2 27 bf f8 st %g1, [ %fp + -8 ]
40019058: 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;
4001905c: 80 a4 40 1b cmp %l1, %i3
40019060: 18 bf ff 99 bgu 40018ec4 <msdos_find_name_in_fat_file+0x108>
40019064: ba 07 60 20 add %i5, 0x20, %i5
40019068: 98 10 00 19 mov %i1, %o4
4001906c: b2 10 00 18 mov %i0, %i1
40019070: b0 10 00 02 mov %g2, %i0
40019074: c4 07 bf e8 ld [ %fp + -24 ], %g2
}
if (remainder_empty)
break;
dir_offset++;
40019078: a8 05 20 01 inc %l4
4001907c: 84 00 80 11 add %g2, %l1, %g2
40019080: 10 bf ff 80 b 40018e80 <msdos_find_name_in_fat_file+0xc4>
40019084: c4 27 bf e8 st %g2, [ %fp + -24 ]
}
break;
}
else if (entry_empty)
{
if (create_node)
40019088: 80 a6 a0 00 cmp %i2, 0
4001908c: 22 bf ff f4 be,a 4001905c <msdos_find_name_in_fat_file+0x2a0>
40019090: 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))
40019094: c2 07 bf ec ld [ %fp + -20 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
40019098: a0 04 20 01 inc %l0
if (empty_space_count == (lfn_entries + 1))
4001909c: 80 a0 40 10 cmp %g1, %l0
400190a0: 22 bf ff ee be,a 40019058 <msdos_find_name_in_fat_file+0x29c>
400190a4: a6 10 20 01 mov 1, %l3
400190a8: 10 bf ff ed b 4001905c <msdos_find_name_in_fat_file+0x2a0>
400190ac: 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)
400190b0: c2 07 bf f8 ld [ %fp + -8 ], %g1
400190b4: 80 a0 7f ff cmp %g1, -1
400190b8: 02 80 00 4e be 400191f0 <msdos_find_name_in_fat_file+0x434>
400190bc: 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) &
400190c0: 86 08 e0 3f and %g3, 0x3f, %g3
400190c4: 80 a0 c0 18 cmp %g3, %i0
400190c8: 22 80 00 05 be,a 400190dc <msdos_find_name_in_fat_file+0x320><== ALWAYS TAKEN
400190cc: 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;
400190d0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
continue;
400190d4: 10 bf ff e1 b 40019058 <msdos_find_name_in_fat_file+0x29c><== NOT EXECUTED
400190d8: 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)) ||
400190dc: 82 0d a0 ff and %l6, 0xff, %g1
400190e0: 88 0a a0 ff and %o2, 0xff, %g4
400190e4: 80 a1 00 01 cmp %g4, %g1
400190e8: 12 bf ff fb bne 400190d4 <msdos_find_name_in_fat_file+0x318><== NEVER TAKEN
400190ec: 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(
400190f0: 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')
400190f4: c4 49 00 00 ldsb [ %g4 ], %g2
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
400190f8: b0 06 3f ff add %i0, -1, %i0
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
400190fc: 83 2e 20 02 sll %i0, 2, %g1
40019100: 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(
40019104: 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;
40019108: 9a 23 40 01 sub %o5, %g1, %o5
4001910c: 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(
40019110: 82 10 20 00 clr %g1
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
40019114: 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')
40019118: 80 a0 a0 00 cmp %g2, 0
4001911c: 02 80 00 16 be 40019174 <msdos_find_name_in_fat_file+0x3b8><== NEVER TAKEN
40019120: 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(
40019124: 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]))
40019128: 80 a2 c0 0c cmp %o3, %o4
4001912c: 04 80 00 ce ble 40019464 <msdos_find_name_in_fat_file+0x6a8>
40019130: 98 02 40 0d add %o1, %o5, %o4
40019134: d8 4b 00 01 ldsb [ %o4 + %g1 ], %o4
40019138: 80 a0 80 0c cmp %g2, %o4
4001913c: 12 80 00 ca bne 40019464 <msdos_find_name_in_fat_file+0x6a8>
40019140: 80 a0 60 04 cmp %g1, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
40019144: 02 80 00 44 be 40019254 <msdos_find_name_in_fat_file+0x498>
40019148: 80 a0 60 0a cmp %g1, 0xa
4001914c: 02 80 00 3e be 40019244 <msdos_find_name_in_fat_file+0x488>
40019150: 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++)
40019154: 02 80 00 12 be 4001919c <msdos_find_name_in_fat_file+0x3e0>
40019158: 88 01 20 02 add %g4, 2, %g4
4001915c: 82 00 60 01 inc %g1
40019160: 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')
40019164: c4 49 00 00 ldsb [ %g4 ], %g2
40019168: 80 a0 a0 00 cmp %g2, 0
4001916c: 12 bf ff ef bne 40019128 <msdos_find_name_in_fat_file+0x36c>
40019170: 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) &&
40019174: c4 07 bf e4 ld [ %fp + -28 ], %g2
40019178: 80 a0 80 03 cmp %g2, %g3
4001917c: 12 80 00 09 bne 400191a0 <msdos_find_name_in_fat_file+0x3e4><== NEVER TAKEN
40019180: 80 a6 20 00 cmp %i0, 0
40019184: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
((o + i) != name_len))
40019188: 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) &&
4001918c: 80 a0 40 02 cmp %g1, %g2
40019190: 02 80 00 03 be 4001919c <msdos_find_name_in_fat_file+0x3e0><== ALWAYS TAKEN
40019194: 82 10 3f ff mov -1, %g1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
40019198: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
4001919c: 80 a6 20 00 cmp %i0, 0
400191a0: 12 80 00 06 bne 400191b8 <msdos_find_name_in_fat_file+0x3fc>
400191a4: 84 10 20 00 clr %g2
400191a8: c2 07 bf f8 ld [ %fp + -8 ], %g1
400191ac: 82 38 00 01 xnor %g0, %g1, %g1
400191b0: 80 a0 00 01 cmp %g0, %g1
400191b4: 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;
400191b8: 10 bf ff a8 b 40019058 <msdos_find_name_in_fat_file+0x29c>
400191bc: 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) &&
400191c0: 80 a0 7f ff cmp %g1, -1
400191c4: 12 bf ff a3 bne 40019050 <msdos_find_name_in_fat_file+0x294><== NEVER TAKEN
400191c8: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
400191cc: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
400191d0: 90 10 00 1d mov %i5, %o0
400191d4: 40 00 0e ea call 4001cd7c <memcmp>
400191d8: 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) &&
400191dc: 80 a2 20 00 cmp %o0, 0
400191e0: 12 bf ff 9c bne 40019050 <msdos_find_name_in_fat_file+0x294>
400191e4: 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,
400191e8: 10 bf ff 6a b 40018f90 <msdos_find_name_in_fat_file+0x1d4>
400191ec: 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) &
400191f0: 80 88 60 ff btst 0xff, %g1
400191f4: 02 bf ff 99 be 40019058 <msdos_find_name_in_fat_file+0x29c>
400191f8: 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) &
400191fc: c2 07 bf e4 ld [ %fp + -28 ], %g1
40019200: 86 08 e0 3f and %g3, 0x3f, %g3
40019204: 80 a0 c0 01 cmp %g3, %g1
40019208: 32 bf ff 95 bne,a 4001905c <msdos_find_name_in_fat_file+0x2a0>
4001920c: b6 06 e0 20 add %i3, 0x20, %i3
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
40019210: e8 27 bf f8 st %l4, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
40019214: f6 27 bf fc st %i3, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
40019218: b0 10 00 01 mov %g1, %i0
4001921c: ec 0f 60 0d ldub [ %i5 + 0xd ], %l6
40019220: 10 bf ff a8 b 400190c0 <msdos_find_name_in_fat_file+0x304>
40019224: 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;
40019228: 31 00 00 1f sethi %hi(0x7c00), %i0
4001922c: aa 10 00 1c mov %i4, %l5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
40019230: 80 a6 a0 00 cmp %i2, 0
40019234: 12 80 00 16 bne 4001928c <msdos_find_name_in_fat_file+0x4d0>
40019238: b0 16 21 01 or %i0, 0x101, %i0
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
4001923c: 81 c7 e0 08 ret
40019240: 81 e8 00 00 restore
{
case 4:
p += 5;
break;
case 10:
p += 4;
40019244: 88 01 20 04 add %g4, 4, %g4
40019248: 82 00 60 01 inc %g1
4001924c: 10 bf ff c6 b 40019164 <msdos_find_name_in_fat_file+0x3a8>
40019250: 9e 03 e0 01 inc %o7
}
switch (i)
{
case 4:
p += 5;
40019254: 88 01 20 05 add %g4, 5, %g4
40019258: 82 00 60 01 inc %g1
4001925c: 10 bf ff c2 b 40019164 <msdos_find_name_in_fat_file+0x3a8>
40019260: 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)
40019264: 80 a6 a0 00 cmp %i2, 0
40019268: 02 80 01 1e be 400196e0 <msdos_find_name_in_fat_file+0x924>
4001926c: 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)
40019270: 80 8c e0 ff btst 0xff, %l3
40019274: 12 80 00 07 bne 40019290 <msdos_find_name_in_fat_file+0x4d4>
40019278: 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;
4001927c: 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);
40019280: b7 36 e0 05 srl %i3, 5, %i3
40019284: 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 +=
40019288: 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)
4001928c: c2 07 a0 58 ld [ %fp + 0x58 ], %g1
40019290: 80 a0 60 02 cmp %g1, 2
40019294: 02 80 01 1d be 40019708 <msdos_find_name_in_fat_file+0x94c>
40019298: 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)
4001929c: c4 07 bf e4 ld [ %fp + -28 ], %g2
400192a0: 80 a0 a0 00 cmp %g2, 0
400192a4: 02 80 00 15 be 400192f8 <msdos_find_name_in_fat_file+0x53c>
400192a8: 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(
400192ac: 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 =
400192b0: 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(
400192b4: 88 00 60 0b add %g1, 0xb, %g4
400192b8: 10 80 00 07 b 400192d4 <msdos_find_name_in_fat_file+0x518>
400192bc: 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 =
400192c0: 84 08 a0 01 and %g2, 1, %g2
400192c4: 80 a0 00 02 cmp %g0, %g2
400192c8: 84 40 3f ff addx %g0, -1, %g2
400192cc: 84 08 a0 80 and %g2, 0x80, %g2
400192d0: 84 00 bf 80 add %g2, -128, %g2
400192d4: fa 08 c0 00 ldub [ %g3 ], %i5
400192d8: 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++)
400192dc: 86 00 e0 01 inc %g3
lfn_checksum =
400192e0: 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++)
400192e4: 80 a0 c0 04 cmp %g3, %g4
lfn_checksum =
400192e8: 82 07 40 01 add %i5, %g1, %g1
400192ec: 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++)
400192f0: 12 bf ff f4 bne 400192c0 <msdos_find_name_in_fat_file+0x504>
400192f4: 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)
400192f8: 80 a4 20 00 cmp %l0, 0
400192fc: 22 80 00 ba be,a 400195e4 <msdos_find_name_in_fat_file+0x828>
40019300: 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;
40019304: a8 1d 00 17 xor %l4, %l7, %l4
40019308: 80 a0 00 14 cmp %g0, %l4
4001930c: ba 40 20 00 addx %g0, 0, %i5
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
40019310: 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;
40019314: 84 10 3f ff mov -1, %g2
40019318: c4 27 bf fc st %g2, [ %fp + -4 ]
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
4001931c: 80 a0 60 00 cmp %g1, 0
40019320: 06 80 00 af bl 400195dc <msdos_find_name_in_fat_file+0x820><== NEVER TAKEN
40019324: 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))
40019328: b8 00 60 01 add %g1, 1, %i4
4001932c: 90 10 00 17 mov %l7, %o0
40019330: 7f ff a4 97 call 4000258c <.umul>
40019334: 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,
40019338: f2 07 a0 48 ld [ %fp + 0x48 ], %i1
4001933c: b0 10 00 08 mov %o0, %i0
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
40019340: a0 10 20 00 clr %l0
40019344: b4 10 00 1c mov %i4, %i2
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
40019348: 80 8f 60 ff btst 0xff, %i5
4001934c: 32 80 00 b9 bne,a 40019630 <msdos_find_name_in_fat_file+0x874>
40019350: 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;
40019354: 80 a4 40 12 cmp %l1, %l2
40019358: 08 80 00 e9 bleu 400196fc <msdos_find_name_in_fat_file+0x940><== NEVER TAKEN
4001935c: 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;
40019360: 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))
40019364: 80 a7 00 14 cmp %i4, %l4
40019368: 02 80 00 e2 be 400196f0 <msdos_find_name_in_fat_file+0x934>
4001936c: 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(
40019370: c4 07 bf e4 ld [ %fp + -28 ], %g2
40019374: 82 38 00 10 xnor %g0, %l0, %g1
40019378: 82 00 40 02 add %g1, %g2, %g1
4001937c: 85 28 60 02 sll %g1, 2, %g2
40019380: 87 28 60 04 sll %g1, 4, %g3
40019384: 84 20 c0 02 sub %g3, %g2, %g2
40019388: 82 00 80 01 add %g2, %g1, %g1
4001938c: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
40019390: a0 10 00 12 mov %l2, %l0
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40019394: 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(
40019398: 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)
4001939c: c2 07 bf f8 ld [ %fp + -8 ], %g1
400193a0: 80 a0 7f ff cmp %g1, -1
400193a4: 22 80 00 96 be,a 400195fc <msdos_find_name_in_fat_file+0x840>
400193a8: ee 27 bf f8 st %l7, [ %fp + -8 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
400193ac: 94 10 20 20 mov 0x20, %o2
400193b0: 90 10 00 16 mov %l6, %o0
400193b4: 40 00 0e d9 call 4001cf18 <memset>
400193b8: 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;
400193bc: 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;
400193c0: 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)
400193c4: 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;
400193c8: 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;
400193cc: 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;
400193d0: 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(
400193d4: 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)
400193d8: 80 a3 e0 00 cmp %o7, 0
400193dc: 02 80 00 11 be 40019420 <msdos_find_name_in_fat_file+0x664><== NEVER TAKEN
400193e0: d4 08 c0 00 ldub [ %g3 ], %o2
{
*p = *n;
400193e4: d4 28 40 00 stb %o2, [ %g1 ]
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
400193e8: 80 a1 20 04 cmp %g4, 4
400193ec: 02 80 00 12 be 40019434 <msdos_find_name_in_fat_file+0x678>
400193f0: 86 00 e0 01 inc %g3
400193f4: 80 a1 20 0a cmp %g4, 0xa
400193f8: 02 80 00 7e be 400195f0 <msdos_find_name_in_fat_file+0x834>
400193fc: 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++)
40019400: 02 80 00 33 be 400194cc <msdos_find_name_in_fat_file+0x710>
40019404: 82 00 60 02 add %g1, 2, %g1
40019408: 84 00 a0 01 inc %g2
{
if (*n != 0)
4001940c: 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(
40019410: 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)
40019414: 80 a3 e0 00 cmp %o7, 0
40019418: 12 bf ff f3 bne 400193e4 <msdos_find_name_in_fat_file+0x628>
4001941c: d4 08 c0 00 ldub [ %g3 ], %o2
*p = *n;
n++;
}
else
{
p [0] = fill;
40019420: d6 28 40 00 stb %o3, [ %g1 ]
p [1] = fill;
40019424: d6 28 60 01 stb %o3, [ %g1 + 1 ]
fill = 0xff;
}
switch (i)
40019428: 80 a1 20 04 cmp %g4, 4
4001942c: 12 bf ff f2 bne 400193f4 <msdos_find_name_in_fat_file+0x638>
40019430: 96 10 3f ff mov -1, %o3
{
case 4:
p += 5;
40019434: 82 00 60 05 add %g1, 5, %g1
40019438: 10 bf ff f5 b 4001940c <msdos_find_name_in_fat_file+0x650>
4001943c: 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) &&
40019440: 80 a0 60 00 cmp %g1, 0
40019444: 32 bf fe 7d bne,a 40018e38 <msdos_find_name_in_fat_file+0x7c><== NEVER TAKEN
40019448: e2 15 60 06 lduh [ %l5 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
4001944c: 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) &&
40019450: 80 88 60 03 btst 3, %g1
40019454: 22 bf fe 79 be,a 40018e38 <msdos_find_name_in_fat_file+0x7c>
40019458: e2 15 60 06 lduh [ %l5 + 6 ], %l1
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
4001945c: 10 bf fe 77 b 40018e38 <msdos_find_name_in_fat_file+0x7c>
40019460: 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;
40019464: 84 10 3f ff mov -1, %g2
40019468: c4 27 bf f8 st %g2, [ %fp + -8 ]
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
4001946c: 80 a6 20 00 cmp %i0, 0
40019470: 12 bf ff 52 bne 400191b8 <msdos_find_name_in_fat_file+0x3fc>
40019474: 84 10 20 00 clr %g2
40019478: 10 bf ff 4d b 400191ac <msdos_find_name_in_fat_file+0x3f0>
4001947c: 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)
40019480: 81 c7 e0 08 ret <== NOT EXECUTED
40019484: 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;
40019488: 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)
4001948c: 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,
40019490: d0 07 a0 60 ld [ %fp + 0x60 ], %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40019494: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
40019498: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
4001949c: 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;
400194a0: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
memcpy(name_dir_entry, entry,
400194a4: 40 00 0e 60 call 4001ce24 <memcpy>
400194a8: 94 10 20 20 mov 0x20, %o2
400194ac: 81 c7 e0 08 ret
400194b0: 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);
400194b4: 40 00 0b b7 call 4001c390 <__errno> <== NOT EXECUTED
400194b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400194bc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400194c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400194c4: 81 c7 e0 08 ret <== NOT EXECUTED
400194c8: 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(
400194cc: 82 26 80 14 sub %i2, %l4, %g1
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
400194d0: 80 a5 20 01 cmp %l4, 1
400194d4: 02 80 00 4c be 40019604 <msdos_find_name_in_fat_file+0x848>
400194d8: c2 2d 80 00 stb %g1, [ %l6 ]
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
400194dc: 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)
400194e0: 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;
400194e4: 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;
400194e8: 80 a4 40 10 cmp %l1, %l0
400194ec: 08 80 00 4e bleu 40019624 <msdos_find_name_in_fat_file+0x868><== NEVER TAKEN
400194f0: 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;
400194f4: ec 05 60 a0 ld [ %l5 + 0xa0 ], %l6
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
400194f8: 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;
400194fc: ac 05 80 10 add %l6, %l0, %l6
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40019500: 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))
40019504: 80 a7 00 14 cmp %i4, %l4
40019508: 12 bf ff a5 bne 4001939c <msdos_find_name_in_fat_file+0x5e0>
4001950c: 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,
40019510: d8 07 a0 5c ld [ %fp + 0x5c ], %o4
40019514: 90 10 00 15 mov %l5, %o0
40019518: 92 10 00 19 mov %i1, %o1
4001951c: 94 10 20 01 mov 1, %o2
40019520: 7f ff e5 8a call 40012b48 <fat_file_ioctl>
40019524: 96 10 00 18 mov %i0, %o3
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
40019528: 80 a2 20 00 cmp %o0, 0
4001952c: 12 bf ff d5 bne 40019480 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
40019530: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
40019534: d2 07 bf f8 ld [ %fp + -8 ], %o1
40019538: 80 a2 7f ff cmp %o1, -1
4001953c: 02 80 00 67 be 400196d8 <msdos_find_name_in_fat_file+0x91c>
40019540: e0 20 a0 04 st %l0, [ %g2 + 4 ]
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40019544: 7f ff a4 12 call 4000258c <.umul>
40019548: 90 10 00 11 mov %l1, %o0
4001954c: 92 10 00 19 mov %i1, %o1
40019550: 96 10 00 08 mov %o0, %o3
40019554: 94 10 20 01 mov 1, %o2
40019558: 90 10 00 15 mov %l5, %o0
4001955c: 7f ff e5 7b call 40012b48 <fat_file_ioctl>
40019560: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
40019564: 80 a2 20 00 cmp %o0, 0
40019568: 12 bf ff c6 bne 40019480 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001956c: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40019570: 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,
40019574: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
40019578: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
4001957c: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40019580: 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;
40019584: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
40019588: 40 00 0e 27 call 4001ce24 <memcpy>
4001958c: 94 10 20 20 mov 0x20, %o2
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
40019590: a0 10 00 14 mov %l4, %l0
40019594: 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,
40019598: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
4001959c: 90 10 00 15 mov %l5, %o0
400195a0: 92 10 00 19 mov %i1, %o1
400195a4: 94 06 00 12 add %i0, %l2, %o2
400195a8: 7f ff e6 32 call 40012e70 <fat_file_write>
400195ac: 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)
400195b0: 80 a2 3f ff cmp %o0, -1
400195b4: 02 80 00 84 be 400197c4 <msdos_find_name_in_fat_file+0xa08><== NEVER TAKEN
400195b8: 80 a2 00 1d cmp %o0, %i5
return ret;
else if (ret != length)
400195bc: 12 bf ff be bne 400194b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
400195c0: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
400195c4: ae 05 e0 01 inc %l7
400195c8: b0 06 00 11 add %i0, %l1, %i0
empty_space_entry = 0;
400195cc: a4 10 20 00 clr %l2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
400195d0: 80 a0 40 10 cmp %g1, %l0
400195d4: 16 bf ff 5d bge 40019348 <msdos_find_name_in_fat_file+0x58c><== NEVER TAKEN
400195d8: ba 10 20 01 mov 1, %i5
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
400195dc: 81 c7 e0 08 ret
400195e0: 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;
400195e4: ba 10 20 01 mov 1, %i5
empty_space_offset = dir_offset;
empty_space_entry = 0;
400195e8: 10 bf ff 4a b 40019310 <msdos_find_name_in_fat_file+0x554>
400195ec: a4 10 20 00 clr %l2
{
case 4:
p += 5;
break;
case 10:
p += 4;
400195f0: 82 00 60 04 add %g1, 4, %g1
400195f4: 10 bf ff 86 b 4001940c <msdos_find_name_in_fat_file+0x650>
400195f8: 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;
400195fc: 10 bf ff 6c b 400193ac <msdos_find_name_in_fat_file+0x5f0>
40019600: 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;
40019604: 82 10 60 40 or %g1, 0x40, %g1
40019608: c2 2d 80 00 stb %g1, [ %l6 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
4001960c: 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)
40019610: 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;
40019614: 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;
40019618: 80 a4 40 10 cmp %l1, %l0
4001961c: 18 bf ff b6 bgu 400194f4 <msdos_find_name_in_fat_file+0x738><== ALWAYS TAKEN
40019620: c2 2d a0 0b stb %g1, [ %l6 + 0xb ]
40019624: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
40019628: 10 bf ff dc b 40019598 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
4001962c: 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,
40019630: 90 10 00 15 mov %l5, %o0
40019634: 92 10 00 19 mov %i1, %o1
40019638: 94 10 00 18 mov %i0, %o2
4001963c: 7f ff e4 4f call 40012778 <fat_file_read>
40019640: 96 10 00 11 mov %l1, %o3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
40019644: 80 a2 00 11 cmp %o0, %l1
40019648: 02 bf ff 43 be 40019354 <msdos_find_name_in_fat_file+0x598><== NEVER TAKEN
4001964c: 80 a2 20 00 cmp %o0, 0
{
if (ret != FAT_EOF)
40019650: 12 80 00 1b bne 400196bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
40019654: 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,
40019658: 92 10 00 19 mov %i1, %o1
4001965c: 94 10 20 00 clr %o2
40019660: 96 10 00 18 mov %i0, %o3
40019664: 7f ff e5 6e call 40012c1c <fat_file_extend>
40019668: 98 07 bf f4 add %fp, -12, %o4
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
4001966c: 80 a2 20 00 cmp %o0, 0
40019670: 12 80 00 57 bne 400197cc <msdos_find_name_in_fat_file+0xa10><== NEVER TAKEN
40019674: 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))
40019678: 80 a0 40 18 cmp %g1, %i0
4001967c: 12 80 00 10 bne 400196bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
40019680: 92 10 20 00 clr %o1
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
40019684: d0 05 60 a0 ld [ %l5 + 0xa0 ], %o0
40019688: 40 00 0e 24 call 4001cf18 <memset>
4001968c: 94 10 00 11 mov %l1, %o2
ret = fat_file_write(&fs_info->fat, fat_fd,
40019690: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
40019694: 90 10 00 15 mov %l5, %o0
40019698: 92 10 00 19 mov %i1, %o1
4001969c: 94 10 00 18 mov %i0, %o2
400196a0: 7f ff e5 f4 call 40012e70 <fat_file_write>
400196a4: 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)
400196a8: 80 a2 3f ff cmp %o0, -1
400196ac: 02 80 00 48 be 400197cc <msdos_find_name_in_fat_file+0xa10><== ALWAYS TAKEN
400196b0: 80 a2 00 11 cmp %o0, %l1
return ret;
else if (ret != bts2rd)
400196b4: 02 bf ff 29 be 40019358 <msdos_find_name_in_fat_file+0x59c><== NOT EXECUTED
400196b8: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
400196bc: 40 00 0b 35 call 4001c390 <__errno> <== NOT EXECUTED
400196c0: 01 00 00 00 nop <== NOT EXECUTED
400196c4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
400196c8: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
400196cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400196d0: 81 c7 e0 08 ret
400196d4: 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)
400196d8: 10 bf ff a6 b 40019570 <msdos_find_name_in_fat_file+0x7b4>
400196dc: 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;
400196e0: 31 00 00 1f sethi %hi(0x7c00), %i0
400196e4: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
400196e8: 81 c7 e0 08 ret
400196ec: 81 e8 00 00 restore
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
400196f0: a0 10 00 12 mov %l2, %l0
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
400196f4: 10 bf ff 87 b 40019510 <msdos_find_name_in_fat_file+0x754>
400196f8: 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;
400196fc: 96 10 20 00 clr %o3 <== NOT EXECUTED
40019700: 10 bf ff a6 b 40019598 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
40019704: 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) /
40019708: 7f ff a3 a1 call 4000258c <.umul>
4001970c: 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 == '.'))
40019710: 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) /
40019714: 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 == '.'))
40019718: 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;
4001971c: 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) /
40019720: bb 32 20 05 srl %o0, 5, %i5
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
40019724: 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 == '.'))
40019728: 80 a0 a0 2e cmp %g2, 0x2e
4001972c: 02 80 00 05 be 40019740 <msdos_find_name_in_fat_file+0x984><== NEVER TAKEN
40019730: ba 00 c0 1d add %g3, %i5, %i5
40019734: 80 a0 a0 20 cmp %g2, 0x20
40019738: 12 80 00 06 bne 40019750 <msdos_find_name_in_fat_file+0x994>
4001973c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
*c = '_';
40019740: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40019744: 84 10 20 5f mov 0x5f, %g2
40019748: 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 == '.'))
4001974c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40019750: c4 48 60 01 ldsb [ %g1 + 1 ], %g2
40019754: 80 a0 a0 2e cmp %g2, 0x2e
40019758: 02 80 00 06 be 40019770 <msdos_find_name_in_fat_file+0x9b4><== NEVER TAKEN
4001975c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40019760: 80 a0 a0 20 cmp %g2, 0x20
40019764: 12 80 00 06 bne 4001977c <msdos_find_name_in_fat_file+0x9c0>
40019768: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
*c = '_';
4001976c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40019770: 84 10 20 5f mov 0x5f, %g2
40019774: 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++)
40019778: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
4001977c: 09 10 00 b2 sethi %hi(0x4002c800), %g4
40019780: 86 00 a0 02 add %g2, 2, %g3
40019784: 88 11 20 d8 or %g4, 0xd8, %g4
40019788: 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];
4001978c: 83 3f 40 02 sra %i5, %g2, %g1
40019790: 82 08 60 0f and %g1, 0xf, %g1
40019794: c2 09 00 01 ldub [ %g4 + %g1 ], %g1
40019798: 84 00 bf fc add %g2, -4, %g2
4001979c: 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++)
400197a0: 80 a0 bf fc cmp %g2, -4
400197a4: 12 bf ff fa bne 4001978c <msdos_find_name_in_fat_file+0x9d0>
400197a8: 86 00 e0 01 inc %g3
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
400197ac: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
400197b0: 84 10 20 7e mov 0x7e, %g2
400197b4: c4 28 60 06 stb %g2, [ %g1 + 6 ]
*c++ = '1';
400197b8: 84 10 20 31 mov 0x31, %g2
400197bc: 10 bf fe b8 b 4001929c <msdos_find_name_in_fat_file+0x4e0>
400197c0: 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)
400197c4: 81 c7 e0 08 ret <== NOT EXECUTED
400197c8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400197cc: 10 bf ff c1 b 400196d0 <msdos_find_name_in_fat_file+0x914>
400197d0: 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);
400197d4: 11 10 00 b4 sethi %hi(0x4002d000), %o0 <== NOT EXECUTED
400197d8: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
400197dc: 17 10 00 b4 sethi %hi(0x4002d000), %o3 <== NOT EXECUTED
400197e0: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
400197e4: 92 10 23 c9 mov 0x3c9, %o1 <== NOT EXECUTED
400197e8: 94 12 a1 d0 or %o2, 0x1d0, %o2 <== NOT EXECUTED
400197ec: 7f ff ac 8c call 40004a1c <__assert_func> <== NOT EXECUTED
400197f0: 96 12 e1 90 or %o3, 0x190, %o3 <== NOT EXECUTED
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
400197f4: 11 10 00 b4 sethi %hi(0x4002d000), %o0 <== NOT EXECUTED
400197f8: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
400197fc: 17 10 00 b4 sethi %hi(0x4002d000), %o3 <== NOT EXECUTED
40019800: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
40019804: 92 10 23 f9 mov 0x3f9, %o1 <== NOT EXECUTED
40019808: 94 12 a1 d0 or %o2, 0x1d0, %o2 <== NOT EXECUTED
4001980c: 7f ff ac 84 call 40004a1c <__assert_func> <== NOT EXECUTED
40019810: 96 12 e1 a0 or %o3, 0x1a0, %o3 <== NOT EXECUTED
40019818 <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
)
{
40019818: 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) &&
4001981c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40019820: 80 a0 60 01 cmp %g1, 1
40019824: 02 80 00 36 be 400198fc <msdos_find_node_by_cluster_num_in_fat_file+0xe4><== NEVER TAKEN
40019828: 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;
4001982c: e2 14 a0 06 lduh [ %l2 + 6 ], %l1
40019830: 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)
40019834: 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);
40019838: 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)
4001983c: 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,
40019840: 90 10 00 12 mov %l2, %o0
40019844: 92 10 00 19 mov %i1, %o1
40019848: 94 10 00 13 mov %l3, %o2
4001984c: 7f ff e3 cb call 40012778 <fat_file_read>
40019850: 96 10 00 11 mov %l1, %o3
40019854: 80 a2 20 00 cmp %o0, 0
40019858: 02 80 00 25 be 400198ec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001985c: 80 a2 20 1f cmp %o0, 0x1f
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
40019860: 04 80 00 42 ble 40019968 <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NEVER TAKEN
40019864: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
40019868: 12 80 00 46 bne 40019980 <msdos_find_node_by_cluster_num_in_fat_file+0x168><== NEVER TAKEN
4001986c: a0 10 20 00 clr %l0
40019870: d8 04 a0 a0 ld [ %l2 + 0xa0 ], %o4
40019874: 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)) ==
40019878: c2 0f 40 00 ldub [ %i5 ], %g1
4001987c: 80 a0 60 00 cmp %g1, 0
40019880: 02 80 00 1b be 400198ec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
40019884: 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)) ==
40019888: 22 80 00 14 be,a 400198d8 <msdos_find_node_by_cluster_num_in_fat_file+0xc0><== NEVER TAKEN
4001988c: 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)
40019890: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
40019894: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
40019898: 83 28 60 10 sll %g1, 0x10, %g1
4001989c: 85 28 a0 10 sll %g2, 0x10, %g2
400198a0: 89 30 60 18 srl %g1, 0x18, %g4
400198a4: 9f 30 a0 18 srl %g2, 0x18, %o7
400198a8: 87 30 60 08 srl %g1, 8, %g3
400198ac: 85 30 a0 08 srl %g2, 8, %g2
400198b0: 86 08 c0 18 and %g3, %i0, %g3
400198b4: 84 08 80 18 and %g2, %i0, %g2
400198b8: 86 11 00 03 or %g4, %g3, %g3
400198bc: 82 13 c0 02 or %o7, %g2, %g1
400198c0: 83 28 60 10 sll %g1, 0x10, %g1
400198c4: 82 10 40 03 or %g1, %g3, %g1
400198c8: 80 a0 40 1a cmp %g1, %i2
400198cc: 22 80 00 16 be,a 40019924 <msdos_find_node_by_cluster_num_in_fat_file+0x10c>
400198d0: 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)
400198d4: a0 04 20 20 add %l0, 0x20, %l0
400198d8: 80 a4 00 11 cmp %l0, %l1
400198dc: 0a bf ff e7 bcs 40019878 <msdos_find_node_by_cluster_num_in_fat_file+0x60><== ALWAYS TAKEN
400198e0: ba 07 60 20 add %i5, 0x20, %i5
400198e4: 10 bf ff d7 b 40019840 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
400198e8: 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;
400198ec: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
400198f0: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
400198f4: 81 c7 e0 08 ret <== NOT EXECUTED
400198f8: 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) &&
400198fc: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
40019900: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40019904: 32 bf ff cb bne,a 40019830 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
40019908: e2 14 a0 06 lduh [ %l2 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
4001990c: 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) &&
40019910: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40019914: 22 bf ff c7 be,a 40019830 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
40019918: 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;
4001991c: 10 bf ff c5 b 40019830 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
40019920: 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,
40019924: 92 10 00 19 mov %i1, %o1
40019928: 94 10 20 01 mov 1, %o2
4001992c: 96 10 00 13 mov %l3, %o3
40019930: 7f ff e4 86 call 40012b48 <fat_file_ioctl>
40019934: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
40019938: b0 92 20 00 orcc %o0, 0, %i0
4001993c: 12 bf ff ee bne 400198f4 <msdos_find_node_by_cluster_num_in_fat_file+0xdc><== NEVER TAKEN
40019940: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
40019944: e0 26 e0 04 st %l0, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40019948: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001994c: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
40019950: 90 10 00 1c mov %i4, %o0
40019954: 92 10 00 1d mov %i5, %o1
40019958: 40 00 0d 33 call 4001ce24 <memcpy>
4001995c: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
40019960: 81 c7 e0 08 ret
40019964: 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 );
40019968: 40 00 0a 8a call 4001c390 <__errno> <== NOT EXECUTED
4001996c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40019970: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40019974: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40019978: 81 c7 e0 08 ret <== NOT EXECUTED
4001997c: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
40019980: 11 10 00 b4 sethi %hi(0x4002d000), %o0 <== NOT EXECUTED
40019984: 15 10 00 b4 sethi %hi(0x4002d000), %o2 <== NOT EXECUTED
40019988: 17 10 00 b4 sethi %hi(0x4002d000), %o3 <== NOT EXECUTED
4001998c: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
40019990: 92 10 26 4e mov 0x64e, %o1 <== NOT EXECUTED
40019994: 94 12 a1 f0 or %o2, 0x1f0, %o2 <== NOT EXECUTED
40019998: 7f ff ac 21 call 40004a1c <__assert_func> <== NOT EXECUTED
4001999c: 96 12 e1 a0 or %o3, 0x1a0, %o3 <== NOT EXECUTED
4000d648 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000d648: 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");
4000d64c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000d650: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000d654: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d658: 7f ff ff 41 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d65c: 94 12 a2 d8 or %o2, 0x2d8, %o2 ! 4002cad8 <_CPU_Trap_slot_template+0x68><== NOT EXECUTED
fd = open(devname, O_RDWR);
4000d660: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d664: 7f ff e0 ba call 4000594c <open> <== NOT EXECUTED
4000d668: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
if (fd == -1) {
4000d66c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
4000d670: 02 80 01 88 be 4000dc90 <msdos_format+0x648> <== NOT EXECUTED
4000d674: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d678: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000d67c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000d680: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000d684: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d688: 7f ff ff 35 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d68c: 94 12 a3 b0 or %o2, 0x3b0, %o2 ! 4002cbb0 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
4000d690: 92 07 bd 60 add %fp, -672, %o1 <== NOT EXECUTED
4000d694: 7f ff dd 70 call 40004c54 <fstat> <== NOT EXECUTED
4000d698: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000d69c: 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);
4000d6a0: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000d6a4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000d6a8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000d6ac: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d6b0: 7f ff ff 2b call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d6b4: 94 12 a3 c0 or %o2, 0x3c0, %o2 ! 4002cbc0 <_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))) {
4000d6b8: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000d6bc: 12 80 00 0c bne 4000d6ec <msdos_format+0xa4> <== NOT EXECUTED
4000d6c0: c4 07 bd 6c ld [ %fp + -660 ], %g2 <== NOT EXECUTED
4000d6c4: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
4000d6c8: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
4000d6cc: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
4000d6d0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000d6d4: 02 80 00 13 be 4000d720 <msdos_format+0xd8> <== NOT EXECUTED
4000d6d8: 92 10 20 00 clr %o1 <== NOT EXECUTED
errno = ENOTTY;
4000d6dc: 40 00 3b 2d call 4001c390 <__errno> <== NOT EXECUTED
4000d6e0: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
4000d6e4: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
4000d6e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000d6ec: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000d6f0: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000d6f4: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
}
/*
* create master boot record
*/
if (ret_val == 0) {
4000d6f8: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000d6fc: 02 80 00 7d be 4000d8f0 <msdos_format+0x2a8> <== NOT EXECUTED
4000d700: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4000d704: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
4000d708: 02 80 00 04 be 4000d718 <msdos_format+0xd0> <== NOT EXECUTED
4000d70c: 01 00 00 00 nop <== NOT EXECUTED
close(fd);
4000d710: 7f ff dd 05 call 40004b24 <close> <== NOT EXECUTED
4000d714: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
return ret_val;
}
4000d718: 81 c7 e0 08 ret <== NOT EXECUTED
4000d71c: 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));
4000d720: 94 10 20 54 mov 0x54, %o2 <== NOT EXECUTED
4000d724: 40 00 3d fd call 4001cf18 <memset> <== NOT EXECUTED
4000d728: 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);
4000d72c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000d730: 3b 10 01 10 sethi %hi(0x40044000), %i5 <== NOT EXECUTED
4000d734: 94 07 bd ac add %fp, -596, %o2 <== NOT EXECUTED
4000d738: 40 00 1e 51 call 4001507c <ioctl> <== NOT EXECUTED
4000d73c: 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) {
4000d740: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED
4000d744: 02 80 01 62 be 4000dccc <msdos_format+0x684> <== NOT EXECUTED
4000d748: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000d74c: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000d750: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000d754: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000d758: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000d75c: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
4000d760: 02 80 01 c7 be 4000de7c <msdos_format+0x834> <== NOT EXECUTED
4000d764: 01 00 00 00 nop <== NOT EXECUTED
4000d768: ae 10 00 02 mov %g2, %l7 <== NOT EXECUTED
4000d76c: 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;
4000d770: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000d774: 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);
4000d778: 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) {
4000d77c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4000d780: 02 80 01 c4 be 4000de90 <msdos_format+0x848> <== NOT EXECUTED
4000d784: 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);
4000d788: 7f ff d3 81 call 4000258c <.umul> <== NOT EXECUTED
4000d78c: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
4000d790: 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);
4000d794: 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 =
4000d798: 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) {
4000d79c: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000d7a0: 12 80 00 46 bne 4000d8b8 <msdos_format+0x270> <== NOT EXECUTED
4000d7a4: 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) &&
4000d7a8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000d7ac: 02 80 03 8d be 4000e5e0 <msdos_format+0xf98> <== NOT EXECUTED
4000d7b0: 09 10 00 b2 sethi %hi(0x4002c800), %g4 <== NOT EXECUTED
(rqdata->OEMName != NULL)) {
4000d7b4: 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) &&
4000d7b8: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
4000d7bc: 22 80 03 89 be,a 4000e5e0 <msdos_format+0xf98> <== NOT EXECUTED
4000d7c0: 09 10 00 b2 sethi %hi(0x4002c800), %g4 <== NOT EXECUTED
4000d7c4: 03 10 00 b6 sethi %hi(0x4002d800), %g1 <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000d7c8: 84 10 20 08 mov 8, %g2 <== NOT EXECUTED
4000d7cc: f4 00 63 44 ld [ %g1 + 0x344 ], %i2 <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000d7d0: b0 10 20 20 mov 0x20, %i0 <== NOT EXECUTED
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
4000d7d4: 10 80 00 07 b 4000d7f0 <msdos_format+0x1a8> <== NOT EXECUTED
4000d7d8: 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++;
4000d7dc: 82 00 60 01 inc %g1 <== NOT EXECUTED
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
4000d7e0: 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;
4000d7e4: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000d7e8: 02 80 00 0e be 4000d820 <msdos_format+0x1d8> <== NOT EXECUTED
4000d7ec: 88 01 20 01 inc %g4 <== NOT EXECUTED
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000d7f0: c6 09 00 00 ldub [ %g4 ], %g3 <== NOT EXECUTED
4000d7f4: ba 08 e0 ff and %g3, 0xff, %i5 <== NOT EXECUTED
4000d7f8: ba 06 80 1d add %i2, %i5, %i5 <== NOT EXECUTED
4000d7fc: fa 4f 60 01 ldsb [ %i5 + 1 ], %i5 <== NOT EXECUTED
4000d800: 80 8f 60 97 btst 0x97, %i5 <== NOT EXECUTED
4000d804: 32 bf ff f6 bne,a 4000d7dc <msdos_format+0x194> <== NOT EXECUTED
4000d808: 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++=' ';
4000d80c: f0 28 40 00 stb %i0, [ %g1 ] <== NOT EXECUTED
4000d810: 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;
4000d814: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000d818: 12 bf ff f6 bne 4000d7f0 <msdos_format+0x1a8> <== NOT EXECUTED
4000d81c: 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) &&
4000d820: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000d824: 02 80 03 71 be 4000e5e8 <msdos_format+0xfa0> <== NOT EXECUTED
4000d828: 09 10 00 b1 sethi %hi(0x4002c400), %g4 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
4000d82c: 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) &&
4000d830: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
4000d834: 22 80 03 6d be,a 4000e5e8 <msdos_format+0xfa0> <== NOT EXECUTED
4000d838: 09 10 00 b1 sethi %hi(0x4002c400), %g4 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
4000d83c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000d840: 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;
4000d844: 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;
4000d848: 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++=' ';
4000d84c: 10 80 00 07 b 4000d868 <msdos_format+0x220> <== NOT EXECUTED
4000d850: 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++;
4000d854: 82 00 60 01 inc %g1 <== NOT EXECUTED
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
4000d858: 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;
4000d85c: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000d860: 02 80 00 0e be 4000d898 <msdos_format+0x250> <== NOT EXECUTED
4000d864: 88 01 20 01 inc %g4 <== NOT EXECUTED
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000d868: c6 09 00 00 ldub [ %g4 ], %g3 <== NOT EXECUTED
4000d86c: ba 08 e0 ff and %g3, 0xff, %i5 <== NOT EXECUTED
4000d870: ba 06 80 1d add %i2, %i5, %i5 <== NOT EXECUTED
4000d874: fa 4f 60 01 ldsb [ %i5 + 1 ], %i5 <== NOT EXECUTED
4000d878: 80 8f 60 97 btst 0x97, %i5 <== NOT EXECUTED
4000d87c: 32 bf ff f6 bne,a 4000d854 <msdos_format+0x20c> <== NOT EXECUTED
4000d880: 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++=' ';
4000d884: f0 28 40 00 stb %i0, [ %g1 ] <== NOT EXECUTED
4000d888: 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;
4000d88c: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000d890: 12 bf ff f6 bne 4000d868 <msdos_format+0x220> <== NOT EXECUTED
4000d894: 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);
4000d898: 40 00 22 51 call 400161dc <rtems_clock_get_tod_timeval> <== NOT EXECUTED
4000d89c: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
if (rc == RTEMS_SUCCESSFUL) {
4000d8a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d8a4: 12 80 03 3d bne 4000e598 <msdos_format+0xf50> <== NOT EXECUTED
4000d8a8: c2 07 be 00 ld [ %fp + -512 ], %g1 <== NOT EXECUTED
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
4000d8ac: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
4000d8b0: 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) &&
4000d8b4: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4000d8b8: 02 bf ff 91 be 4000d6fc <msdos_format+0xb4> <== NOT EXECUTED
4000d8bc: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
(rqdata != NULL) &&
4000d8c0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1 <== NOT EXECUTED
4000d8c4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d8c8: 12 80 00 0a bne 4000d8f0 <msdos_format+0x2a8> <== NOT EXECUTED
4000d8cc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4000d8d0: d6 07 bd b0 ld [ %fp + -592 ], %o3 <== NOT EXECUTED
4000d8d4: d8 07 bd ac ld [ %fp + -596 ], %o4 <== NOT EXECUTED
4000d8d8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d8dc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000d8e0: 7f ff fe cc call 4000d410 <msdos_format_fill_sectors> <== NOT EXECUTED
4000d8e4: 9a 10 3f e5 mov -27, %o5 <== NOT EXECUTED
4000d8e8: 10 bf ff 84 b 4000d6f8 <msdos_format+0xb0> <== NOT EXECUTED
4000d8ec: 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,
4000d8f0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000d8f4: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d8f8: 7f ff fe 99 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d8fc: 94 12 a3 60 or %o2, 0x360, %o2 ! 4002cb60 <_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)) {
4000d900: 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,
4000d904: 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)) {
4000d908: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000d90c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000d910: 40 00 1d fc call 40015100 <lseek> <== NOT EXECUTED
4000d914: 96 10 20 00 clr %o3 <== NOT EXECUTED
4000d918: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d91c: 06 80 01 16 bl 4000dd74 <msdos_format+0x72c> <== NOT EXECUTED
4000d920: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
4000d924: 92 07 be 00 add %fp, -512, %o1 <== NOT EXECUTED
4000d928: 40 00 1e cc call 40015458 <read> <== NOT EXECUTED
4000d92c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000d930: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d934: 06 80 01 10 bl 4000dd74 <msdos_format+0x72c> <== NOT EXECUTED
4000d938: 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,
4000d93c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000d940: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d944: 7f ff fe 86 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d948: 94 12 a3 d0 or %o2, 0x3d0, %o2 ! 4002cbd0 <_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) {
4000d94c: c2 07 bd b0 ld [ %fp + -592 ], %g1 <== NOT EXECUTED
4000d950: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED
4000d954: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff> <== NOT EXECUTED
4000d958: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000d95c: 08 80 02 f9 bleu 4000e540 <msdos_format+0xef8> <== NOT EXECUTED
4000d960: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
4000d964: 84 08 40 02 and %g1, %g2, %g2 <== NOT EXECUTED
4000d968: a8 10 00 01 mov %g1, %l4 <== NOT EXECUTED
4000d96c: a7 30 a0 08 srl %g2, 8, %l3 <== NOT EXECUTED
4000d970: a5 30 60 10 srl %g1, 0x10, %l2 <== NOT EXECUTED
4000d974: a3 30 60 18 srl %g1, 0x18, %l1 <== NOT EXECUTED
4000d978: a0 10 20 00 clr %l0 <== NOT EXECUTED
4000d97c: 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);
4000d980: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000d984: 94 10 21 be mov 0x1be, %o2 <== NOT EXECUTED
4000d988: 40 00 3d 64 call 4001cf18 <memset> <== NOT EXECUTED
4000d98c: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000d990: 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,
4000d994: c0 37 bf fe clrh [ %fp + -2 ] <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000d998: 92 07 bd df add %fp, -545, %o1 <== NOT EXECUTED
4000d99c: 40 00 3d 22 call 4001ce24 <memcpy> <== NOT EXECUTED
4000d9a0: 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);
4000d9a4: 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);
4000d9a8: 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);
4000d9ac: 83 30 a0 08 srl %g2, 8, %g1 <== NOT EXECUTED
4000d9b0: 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);
4000d9b4: 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);
4000d9b8: 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);
4000d9bc: 9b 31 20 08 srl %g4, 8, %o5 <== NOT EXECUTED
4000d9c0: c8 2f be 0b stb %g4, [ %fp + -501 ] <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000d9c4: 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) {
4000d9c8: 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);
4000d9cc: c2 2f be 15 stb %g1, [ %fp + -491 ] <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4000d9d0: 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);
4000d9d4: 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 */
4000d9d8: 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... */
4000d9dc: 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... */
4000d9e0: 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);
4000d9e4: 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... */
4000d9e8: 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);
4000d9ec: c8 2f be 0d stb %g4, [ %fp + -499 ] <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4000d9f0: c6 2f be 0e stb %g3, [ %fp + -498 ] <== NOT EXECUTED
4000d9f4: 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 */
4000d9f8: f4 2f be 10 stb %i2, [ %fp + -496 ] <== NOT EXECUTED
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000d9fc: c4 2f be 11 stb %g2, [ %fp + -495 ] <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4000da00: f0 2f be 13 stb %i0, [ %fp + -493 ] <== NOT EXECUTED
4000da04: 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... */
4000da08: c2 2f be 1a stb %g1, [ %fp + -486 ] <== NOT EXECUTED
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4000da0c: f8 2f be 1c stb %i4, [ %fp + -484 ] <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000da10: e8 2f be 20 stb %l4, [ %fp + -480 ] <== NOT EXECUTED
4000da14: e6 2f be 21 stb %l3, [ %fp + -479 ] <== NOT EXECUTED
4000da18: e4 2f be 22 stb %l2, [ %fp + -478 ] <== NOT EXECUTED
if (fmt_params->fattype != FAT_FAT32) {
4000da1c: 80 a7 60 04 cmp %i5, 4 <== NOT EXECUTED
4000da20: 02 80 02 f7 be 4000e5fc <msdos_format+0xfb4> <== NOT EXECUTED
4000da24: 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 */
4000da28: 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);
4000da2c: 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 */
4000da30: 89 30 60 10 srl %g1, 0x10, %g4 <== NOT EXECUTED
4000da34: 87 30 60 18 srl %g1, 0x18, %g3 <== NOT EXECUTED
4000da38: b9 30 60 08 srl %g1, 8, %i4 <== NOT EXECUTED
4000da3c: 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);
4000da40: 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);
4000da44: 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);
4000da48: 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);
4000da4c: c4 2f be 16 stb %g2, [ %fp + -490 ] <== NOT EXECUTED
4000da50: 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 */
4000da54: f8 2f be 28 stb %i4, [ %fp + -472 ] <== NOT EXECUTED
4000da58: c8 2f be 29 stb %g4, [ %fp + -471 ] <== NOT EXECUTED
4000da5c: c6 2f be 2a stb %g3, [ %fp + -470 ] <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4000da60: 90 07 be 2b add %fp, -469, %o0 <== NOT EXECUTED
4000da64: 92 07 bd e8 add %fp, -536, %o1 <== NOT EXECUTED
4000da68: 40 00 3c ef call 4001ce24 <memcpy> <== NOT EXECUTED
4000da6c: 94 10 20 0b mov 0xb, %o2 <== NOT EXECUTED
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4000da70: 03 10 00 b2 sethi %hi(0x4002c800), %g1 <== NOT EXECUTED
4000da74: 80 a7 60 01 cmp %i5, 1 <== NOT EXECUTED
4000da78: 02 80 02 c2 be 4000e580 <msdos_format+0xf38> <== NOT EXECUTED
4000da7c: 82 10 62 c0 or %g1, 0x2c0, %g1 <== NOT EXECUTED
4000da80: c4 10 40 00 lduh [ %g1 ], %g2 <== NOT EXECUTED
4000da84: c4 37 be 36 sth %g2, [ %fp + -458 ] <== NOT EXECUTED
4000da88: c4 10 60 02 lduh [ %g1 + 2 ], %g2 <== NOT EXECUTED
4000da8c: c4 37 be 38 sth %g2, [ %fp + -456 ] <== NOT EXECUTED
4000da90: c4 10 60 04 lduh [ %g1 + 4 ], %g2 <== NOT EXECUTED
4000da94: c4 37 be 3a sth %g2, [ %fp + -454 ] <== NOT EXECUTED
4000da98: c2 10 60 06 lduh [ %g1 + 6 ], %g1 <== NOT EXECUTED
4000da9c: 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);
4000daa0: 82 10 20 55 mov 0x55, %g1 <== NOT EXECUTED
4000daa4: c2 2f bf fe stb %g1, [ %fp + -2 ] <== NOT EXECUTED
4000daa8: 82 10 3f aa mov -86, %g1 <== NOT EXECUTED
4000daac: 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);
4000dab0: 82 10 3f eb mov -21, %g1 <== NOT EXECUTED
4000dab4: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
FAT_SET_VAL8(mbr,1,0x3c);
4000dab8: 82 10 20 3c mov 0x3c, %g1 <== NOT EXECUTED
4000dabc: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
FAT_SET_VAL8(mbr,2,0x90);
4000dac0: 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,
4000dac4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000dac8: 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);
4000dacc: 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,
4000dad0: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000dad4: 7f ff fe 22 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000dad8: 94 12 a3 78 or %o2, 0x378, %o2 ! 4002cb78 <_CPU_Trap_slot_template+0x108><== NOT EXECUTED
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000dadc: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
4000dae0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000dae4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000dae8: 7f ff fe 32 call 4000d3b0 <msdos_format_write_sec> <== NOT EXECUTED
4000daec: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4000daf0: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000daf4: 12 bf ff 04 bne 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000daf8: c2 07 bd d4 ld [ %fp + -556 ], %g1 <== NOT EXECUTED
4000dafc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000db00: 12 80 02 aa bne 4000e5a8 <msdos_format+0xf60> <== NOT EXECUTED
4000db04: 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)) {
4000db08: fa 07 bd d8 ld [ %fp + -552 ], %i5 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000db0c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000db10: 12 80 00 9b bne 4000dd7c <msdos_format+0x734> <== NOT EXECUTED
4000db14: 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,
4000db18: d0 0f bd dc ldub [ %fp + -548 ], %o0 <== NOT EXECUTED
4000db1c: 7f ff d2 9c call 4000258c <.umul> <== NOT EXECUTED
4000db20: 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
4000db24: d8 07 bd ac ld [ %fp + -596 ], %o4 <== NOT EXECUTED
(rqdata,
4000db28: 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
4000db2c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000db30: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000db34: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000db38: 7f ff fe 36 call 4000d410 <msdos_format_fill_sectors> <== NOT EXECUTED
4000db3c: 9a 10 20 00 clr %o5 <== NOT EXECUTED
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4000db40: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000db44: 12 bf fe f0 bne 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000db48: d4 07 bd cc ld [ %fp + -564 ], %o2 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
4000db4c: d6 07 bd d0 ld [ %fp + -560 ], %o3 <== NOT EXECUTED
4000db50: d8 07 bd ac ld [ %fp + -596 ], %o4 <== NOT EXECUTED
4000db54: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000db58: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000db5c: 7f ff fe 2d call 4000d410 <msdos_format_fill_sectors> <== NOT EXECUTED
4000db60: 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) {
4000db64: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000db68: 12 bf fe e7 bne 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000db6c: c2 0f bd f4 ldub [ %fp + -524 ], %g1 <== NOT EXECUTED
4000db70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000db74: 12 80 00 a9 bne 4000de18 <msdos_format+0x7d0> <== NOT EXECUTED
4000db78: 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));
4000db7c: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
4000db80: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000db84: 40 00 3c e5 call 4001cf18 <memset> <== NOT EXECUTED
4000db88: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
switch(fmt_params.fattype) {
4000db8c: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
4000db90: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
4000db94: 02 80 00 e2 be 4000df1c <msdos_format+0x8d4> <== NOT EXECUTED
4000db98: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000db9c: 02 80 00 c4 be 4000deac <msdos_format+0x864> <== NOT EXECUTED
4000dba0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
4000dba4: 02 80 00 d7 be 4000df00 <msdos_format+0x8b8> <== NOT EXECUTED
4000dba8: 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;
4000dbac: 40 00 39 f9 call 4001c390 <__errno> <== NOT EXECUTED
4000dbb0: 01 00 00 00 nop <== NOT EXECUTED
4000dbb4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
4000dbb8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4000dbbc: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
4000dbc0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000dbc4: 02 80 00 c7 be 4000dee0 <msdos_format+0x898> <== NOT EXECUTED
4000dbc8: 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)
4000dbcc: 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,
4000dbd0: 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)
4000dbd4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000dbd8: 12 80 00 06 bne 4000dbf0 <msdos_format+0x5a8> <== NOT EXECUTED
4000dbdc: c4 07 bd b8 ld [ %fp + -584 ], %g2 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000dbe0: b8 07 00 02 add %i4, %g2, %i4 <== NOT EXECUTED
4000dbe4: 84 20 00 02 neg %g2 <== NOT EXECUTED
4000dbe8: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
4000dbec: 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;
4000dbf0: c2 0f bd dc ldub [ %fp + -548 ], %g1 <== NOT EXECUTED
4000dbf4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000dbf8: 02 80 02 b0 be 4000e6b8 <msdos_format+0x1070> <== NOT EXECUTED
4000dbfc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
4000dc00: 12 80 00 5a bne 4000dd68 <msdos_format+0x720> <== NOT EXECUTED
4000dc04: 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;
4000dc08: 10 80 00 05 b 4000dc1c <msdos_format+0x5d4> <== NOT EXECUTED
4000dc0c: ba 10 20 00 clr %i5 <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
4000dc10: 32 bf fe bd bne,a 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000dc14: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
4000dc18: 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),
4000dc1c: 7f ff d2 5c call 4000258c <.umul> <== NOT EXECUTED
4000dc20: 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
4000dc24: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
(fd,
4000dc28: 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
4000dc2c: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
4000dc30: 7f ff fd e0 call 4000d3b0 <msdos_format_write_sec> <== NOT EXECUTED
4000dc34: 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);
4000dc38: c2 0f bd dc ldub [ %fp + -548 ], %g1 <== NOT EXECUTED
i++) {
4000dc3c: 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;
4000dc40: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
4000dc44: 14 bf ff f3 bg 4000dc10 <msdos_format+0x5c8> <== NOT EXECUTED
4000dc48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dc4c: c4 0f bd 57 ldub [ %fp + -681 ], %g2 <== NOT EXECUTED
4000dc50: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000dc54: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
4000dc58: 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) {
4000dc5c: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
4000dc60: 22 bf fe a9 be,a 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000dc64: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
4000dc68: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1 <== NOT EXECUTED
4000dc6c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000dc70: 02 bf fe a6 be 4000d708 <msdos_format+0xc0> <== NOT EXECUTED
4000dc74: 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);
4000dc78: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000dc7c: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
4000dc80: 40 00 1c ff call 4001507c <ioctl> <== NOT EXECUTED
4000dc84: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_SIZE+0x1fc04206><== NOT EXECUTED
4000dc88: 10 bf fe 9f b 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000dc8c: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dc90: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000dc94: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000dc98: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000dc9c: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000dca0: 7f ff fd af call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000dca4: 94 12 a3 b0 or %o2, 0x3b0, %o2 ! 4002cbb0 <_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,
4000dca8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000dcac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000dcb0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000dcb4: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000dcb8: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
4000dcbc: 7f ff fd a8 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000dcc0: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED
4000dcc4: 10 bf fe 8b b 4000d6f0 <msdos_format+0xa8> <== NOT EXECUTED
4000dcc8: 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);
4000dccc: 92 17 62 05 or %i5, 0x205, %o1 <== NOT EXECUTED
4000dcd0: 40 00 1c eb call 4001507c <ioctl> <== NOT EXECUTED
4000dcd4: 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) {
4000dcd8: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED
4000dcdc: 12 bf fe 9c bne 4000d74c <msdos_format+0x104> <== NOT EXECUTED
4000dce0: f0 07 bd ac ld [ %fp + -596 ], %i0 <== NOT EXECUTED
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000dce4: f4 07 bd b0 ld [ %fp + -592 ], %i2 <== NOT EXECUTED
4000dce8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000dcec: 7f ff d2 28 call 4000258c <.umul> <== NOT EXECUTED
4000dcf0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dcf4: 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;
4000dcf8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dcfc: 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;
4000dd00: b8 10 20 00 clr %i4 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000dd04: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000dd08: f8 3f bd 58 std %i4, [ %fp + -680 ] <== NOT EXECUTED
4000dd0c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000dd10: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000dd14: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000dd18: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000dd1c: 7f ff fd 90 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000dd20: 94 12 a2 e8 or %o2, 0x2e8, %o2 <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000dd24: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000dd28: 02 80 02 69 be 4000e6cc <msdos_format+0x1084> <== NOT EXECUTED
4000dd2c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
(rqdata->fat_num == 0)) {
4000dd30: d6 06 60 0c ld [ %i1 + 0xc ], %o3 <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000dd34: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4000dd38: 22 80 00 82 be,a 4000df40 <msdos_format+0x8f8> <== NOT EXECUTED
4000dd3c: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
4000dd40: 80 a2 e0 06 cmp %o3, 6 <== NOT EXECUTED
4000dd44: 18 80 02 09 bgu 4000e568 <msdos_format+0xf20> <== NOT EXECUTED
4000dd48: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
4000dd4c: 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,
4000dd50: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000dd54: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000dd58: 7f ff fd 81 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000dd5c: 94 12 a3 28 or %o2, 0x328, %o2 ! 4002cb28 <_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) {
4000dd60: 10 80 00 7f b 4000df5c <msdos_format+0x914> <== NOT EXECUTED
4000dd64: 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);
4000dd68: 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) {
4000dd6c: 10 bf fe 66 b 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000dd70: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000dd74: 10 bf fe 64 b 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000dd78: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4000dd7c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000dd80: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
4000dd84: 40 00 3c 65 call 4001cf18 <memset> <== NOT EXECUTED
4000dd88: 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 );
4000dd8c: 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,
4000dd90: 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 );
4000dd94: c4 2f be 02 stb %g2, [ %fp + -510 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000dd98: c4 2f bf e7 stb %g2, [ %fp + -25 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000dd9c: 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,
4000dda0: 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 );
4000dda4: 86 10 20 41 mov 0x41, %g3 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000dda8: 88 10 20 72 mov 0x72, %g4 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000ddac: c4 2f bf fe stb %g2, [ %fp + -2 ] <== NOT EXECUTED
4000ddb0: 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 );
4000ddb4: b8 10 20 52 mov 0x52, %i4 <== NOT EXECUTED
4000ddb8: c6 2f be 03 stb %g3, [ %fp + -509 ] <== NOT EXECUTED
4000ddbc: f8 2f be 00 stb %i4, [ %fp + -512 ] <== NOT EXECUTED
4000ddc0: f8 2f be 01 stb %i4, [ %fp + -511 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000ddc4: c8 2f bf e4 stb %g4, [ %fp + -28 ] <== NOT EXECUTED
4000ddc8: c8 2f bf e5 stb %g4, [ %fp + -27 ] <== NOT EXECUTED
4000ddcc: c6 2f bf e6 stb %g3, [ %fp + -26 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000ddd0: 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,
4000ddd4: c2 2f bf e8 stb %g1, [ %fp + -24 ] <== NOT EXECUTED
4000ddd8: c2 2f bf e9 stb %g1, [ %fp + -23 ] <== NOT EXECUTED
4000dddc: c2 2f bf ea stb %g1, [ %fp + -22 ] <== NOT EXECUTED
4000dde0: c2 2f bf eb stb %g1, [ %fp + -21 ] <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
4000dde4: c2 2f bf ec stb %g1, [ %fp + -20 ] <== NOT EXECUTED
4000dde8: c2 2f bf ed stb %g1, [ %fp + -19 ] <== NOT EXECUTED
4000ddec: c2 2f bf ee stb %g1, [ %fp + -18 ] <== NOT EXECUTED
4000ddf0: 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,
4000ddf4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000ddf8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000ddfc: 7f ff fd 6d call 4000d3b0 <msdos_format_write_sec> <== NOT EXECUTED
4000de00: 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) {
4000de04: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000de08: 12 bf fe 40 bne 4000d708 <msdos_format+0xc0> <== NOT EXECUTED
4000de0c: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
(rqdata,
4000de10: 10 bf ff 42 b 4000db18 <msdos_format+0x4d0> <== NOT EXECUTED
4000de14: 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));
4000de18: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
4000de1c: 40 00 3c 3f call 4001cf18 <memset> <== NOT EXECUTED
4000de20: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4000de24: c2 0f bd f2 ldub [ %fp + -526 ], %g1 <== NOT EXECUTED
4000de28: c6 07 bd ec ld [ %fp + -532 ], %g3 <== NOT EXECUTED
4000de2c: c4 17 bd f0 lduh [ %fp + -528 ], %g2 <== NOT EXECUTED
4000de30: 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
4000de34: d2 07 bd cc ld [ %fp + -564 ], %o1 <== NOT EXECUTED
4000de38: 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);
4000de3c: c2 2f be 0a stb %g1, [ %fp + -502 ] <== NOT EXECUTED
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4000de40: 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);
4000de44: c8 27 be 00 st %g4, [ %fp + -512 ] <== NOT EXECUTED
4000de48: c6 27 be 04 st %g3, [ %fp + -508 ] <== NOT EXECUTED
4000de4c: 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
4000de50: 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;
4000de54: c2 2f be 0b stb %g1, [ %fp + -501 ] <== NOT EXECUTED
ret_val = msdos_format_write_sec
4000de58: 7f ff fd 56 call 4000d3b0 <msdos_format_write_sec> <== NOT EXECUTED
4000de5c: 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) {
4000de60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000de64: 22 bf ff 47 be,a 4000db80 <msdos_format+0x538> <== NOT EXECUTED
4000de68: 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) {
4000de6c: 10 bf fe 26 b 4000d704 <msdos_format+0xbc> <== NOT EXECUTED
4000de70: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
4000de74: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000de78: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
4000de7c: 40 00 39 45 call 4001c390 <__errno> <== NOT EXECUTED
4000de80: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
4000de84: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000de88: 10 bf fe 39 b 4000d76c <msdos_format+0x124> <== NOT EXECUTED
4000de8c: 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);
4000de90: 7f ff d1 bf call 4000258c <.umul> <== NOT EXECUTED
4000de94: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000de98: 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);
4000de9c: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000dea0: 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 =
4000dea4: 10 bf fe 3e b 4000d79c <msdos_format+0x154> <== NOT EXECUTED
4000dea8: 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);
4000deac: c4 0f bd dd ldub [ %fp + -547 ], %g2 <== NOT EXECUTED
4000deb0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000deb4: c4 2f be 00 stb %g2, [ %fp + -512 ] <== NOT EXECUTED
4000deb8: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
4000debc: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
4000dec0: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000dec4: 84 10 3f f8 mov -8, %g2 <== NOT EXECUTED
4000dec8: c2 2f be 05 stb %g1, [ %fp + -507 ] <== NOT EXECUTED
4000decc: c2 2f be 06 stb %g1, [ %fp + -506 ] <== NOT EXECUTED
4000ded0: c4 2f be 04 stb %g2, [ %fp + -508 ] <== NOT EXECUTED
4000ded4: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
4000ded8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000dedc: 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);
4000dee0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000dee4: 84 10 3f f8 mov -8, %g2 <== NOT EXECUTED
4000dee8: c2 2f be 09 stb %g1, [ %fp + -503 ] <== NOT EXECUTED
4000deec: c2 2f be 0a stb %g1, [ %fp + -502 ] <== NOT EXECUTED
4000def0: c4 2f be 08 stb %g2, [ %fp + -504 ] <== NOT EXECUTED
4000def4: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
4000def8: 10 bf ff 35 b 4000dbcc <msdos_format+0x584> <== NOT EXECUTED
4000defc: 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;
4000df00: 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));
4000df04: 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)));
4000df08: 82 10 3f 8f mov -113, %g1 <== NOT EXECUTED
4000df0c: 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));
4000df10: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000df14: 10 bf ff 2e b 4000dbcc <msdos_format+0x584> <== NOT EXECUTED
4000df18: 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);
4000df1c: c4 0f bd dd ldub [ %fp + -547 ], %g2 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
4000df20: 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);
4000df24: c4 2f be 00 stb %g2, [ %fp + -512 ] <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
4000df28: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4000df2c: 84 10 3f f8 mov -8, %g2 <== NOT EXECUTED
4000df30: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
4000df34: 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;
4000df38: 10 bf ff 25 b 4000dbcc <msdos_format+0x584> <== NOT EXECUTED
4000df3c: 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;
4000df40: 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,
4000df44: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000df48: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000df4c: 94 12 a3 28 or %o2, 0x328, %o2 <== NOT EXECUTED
4000df50: 7f ff fd 03 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000df54: 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) {
4000df58: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4000df5c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000df60: 02 80 01 75 be 4000e534 <msdos_format+0xeec> <== NOT EXECUTED
4000df64: 07 00 00 1f sethi %hi(0x7c00), %g3 <== NOT EXECUTED
4000df68: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
4000df6c: 87 28 60 0a sll %g1, 0xa, %g3 <== NOT EXECUTED
4000df70: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED
4000df74: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED
4000df78: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED
4000df7c: 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) {
4000df80: c4 07 bd b0 ld [ %fp + -592 ], %g2 <== NOT EXECUTED
4000df84: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000df88: 1a 80 01 4f bcc 4000e4c4 <msdos_format+0xe7c> <== NOT EXECUTED
4000df8c: 87 28 60 02 sll %g1, 2, %g3 <== NOT EXECUTED
fmt_params->fattype = FAT_FAT12;
4000df90: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000df94: c2 2f bd de stb %g1, [ %fp + -546 ] <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000df98: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
4000df9c: 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 );
4000dfa0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000dfa4: 7f ff fd 88 call 4000d5c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000dfa8: 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
4000dfac: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000dfb0: 12 80 01 d2 bne 4000e6f8 <msdos_format+0x10b0> <== NOT EXECUTED
4000dfb4: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
&& fmt_params->fattype != fat_type
4000dfb8: 80 a0 60 ff cmp %g1, 0xff <== NOT EXECUTED
4000dfbc: 02 80 01 d5 be 4000e710 <msdos_format+0x10c8> <== NOT EXECUTED
4000dfc0: c2 07 bd b0 ld [ %fp + -592 ], %g1 <== NOT EXECUTED
&& fmt_params->totl_sector_cnt > 0 ) {
4000dfc4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000dfc8: 02 bf ff ab be 4000de74 <msdos_format+0x82c> <== NOT EXECUTED
4000dfcc: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000dfd0: 84 40 20 00 addx %g0, 0, %g2 <== NOT EXECUTED
4000dfd4: c4 2f bd 57 stb %g2, [ %fp + -681 ] <== NOT EXECUTED
4000dfd8: 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;
4000dfdc: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000dfe0: 1b 10 00 00 sethi %hi(0x40000000), %o5 <== NOT EXECUTED
4000dfe4: 86 87 40 0d addcc %i5, %o5, %g3 <== NOT EXECUTED
4000dfe8: 84 47 00 0c addx %i4, %o4, %g2 <== NOT EXECUTED
4000dfec: a6 10 20 00 clr %l3 <== NOT EXECUTED
4000dff0: 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
4000dff4: 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;
4000dff8: 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
4000dffc: 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;
4000e000: 84 11 00 02 or %g4, %g2, %g2 <== NOT EXECUTED
4000e004: 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)
4000e008: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4000e00c: 02 80 00 05 be 4000e020 <msdos_format+0x9d8> <== NOT EXECUTED
4000e010: d6 07 bd b8 ld [ %fp + -584 ], %o3 <== NOT EXECUTED
fmt_params->skip_alignment = rqdata->skip_alignment;
4000e014: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1 <== NOT EXECUTED
4000e018: c2 2f bd fc stb %g1, [ %fp + -516 ] <== NOT EXECUTED
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000e01c: d6 07 bd b8 ld [ %fp + -584 ], %o3 <== NOT EXECUTED
4000e020: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e024: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000e028: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000e02c: 7f ff fc cc call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000e030: 94 12 a3 40 or %o2, 0x340, %o2 ! 4002cb40 <_CPU_Trap_slot_template+0xd0><== NOT EXECUTED
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
4000e034: fa 0f bd de ldub [ %fp + -546 ], %i5 <== NOT EXECUTED
4000e038: 80 a7 60 04 cmp %i5, 4 <== NOT EXECUTED
4000e03c: 02 80 01 13 be 4000e488 <msdos_format+0xe40> <== NOT EXECUTED
4000e040: 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) &&
4000e044: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4000e048: 02 80 01 0a be 4000e470 <msdos_format+0xe28> <== NOT EXECUTED
4000e04c: c8 27 bd b4 st %g4, [ %fp + -588 ] <== NOT EXECUTED
(rqdata->files_per_root_dir > 0)) {
4000e050: 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) &&
4000e054: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e058: 02 80 01 07 be 4000e474 <msdos_format+0xe2c> <== NOT EXECUTED
4000e05c: 82 1f 60 02 xor %i5, 2, %g1 <== NOT EXECUTED
4000e060: 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/
4000e064: 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 %
4000e068: 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/
4000e06c: 93 2e e0 01 sll %i3, 1, %o1 <== NOT EXECUTED
4000e070: 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 +
4000e074: 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 %
4000e078: 40 00 6d 20 call 400294f8 <.urem> <== NOT EXECUTED
4000e07c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e080: 90 27 00 08 sub %i4, %o0, %o0 <== NOT EXECUTED
4000e084: d0 27 bd c4 st %o0, [ %fp + -572 ] <== NOT EXECUTED
4000e088: 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);
4000e08c: 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)
4000e090: a4 06 ff ff add %i3, -1, %l2 <== NOT EXECUTED
/ fmt_params->bytes_per_sector);
4000e094: 7f ff d1 78 call 40002674 <.udiv> <== NOT EXECUTED
4000e098: 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,
4000e09c: 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);
4000e0a0: 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 =
4000e0a4: 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) {
4000e0a8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e0ac: 7f ff d1 72 call 40002674 <.udiv> <== NOT EXECUTED
4000e0b0: 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,
4000e0b4: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000e0b8: 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) {
4000e0bc: 80 a5 c0 08 cmp %l7, %o0 <== NOT EXECUTED
4000e0c0: 08 80 00 06 bleu 4000e0d8 <msdos_format+0xa90> <== NOT EXECUTED
4000e0c4: f4 0f bd fc ldub [ %fp + -516 ], %i2 <== NOT EXECUTED
sectors_per_cluster /= 2;
4000e0c8: 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) {
4000e0cc: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
4000e0d0: 2a bf ff ff bcs,a 4000e0cc <msdos_format+0xa84> <== NOT EXECUTED
4000e0d4: 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);
4000e0d8: 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
4000e0dc: 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);
4000e0e0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4000e0e4: a2 0c 60 ff and %l1, 0xff, %l1 <== NOT EXECUTED
4000e0e8: 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
4000e0ec: 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);
4000e0f0: a8 05 3f ff add %l4, -1, %l4 <== NOT EXECUTED
4000e0f4: 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)
4000e0f8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4000e0fc: 02 80 00 0a be 4000e124 <msdos_format+0xadc> <== NOT EXECUTED
4000e100: 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) {
4000e104: 80 a7 60 01 cmp %i5, 1 <== NOT EXECUTED
4000e108: 02 80 01 8e be 4000e740 <msdos_format+0x10f8> <== NOT EXECUTED
4000e10c: 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) {
4000e110: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000e114: 12 80 00 0c bne 4000e144 <msdos_format+0xafc> <== NOT EXECUTED
4000e118: 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;
4000e11c: 10 80 00 99 b 4000e380 <msdos_format+0xd38> <== NOT EXECUTED
4000e120: 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);
4000e124: 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) {
4000e128: 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);
4000e12c: 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) {
4000e130: 02 80 00 86 be 4000e348 <msdos_format+0xd00> <== NOT EXECUTED
4000e134: 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) {
4000e138: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000e13c: 02 80 00 8e be 4000e374 <msdos_format+0xd2c> <== NOT EXECUTED
4000e140: 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;
4000e144: 7f ff d1 4c call 40002674 <.udiv> <== NOT EXECUTED
4000e148: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
4000e14c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 4;
4000e150: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
4000e154: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e158: 7f ff d1 47 call 40002674 <.udiv> <== NOT EXECUTED
4000e15c: 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,
4000e160: 7f ff d1 0b call 4000258c <.umul> <== NOT EXECUTED
4000e164: 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)
4000e168: 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,
4000e16c: 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)
4000e170: 12 80 00 05 bne 4000e184 <msdos_format+0xb3c> <== NOT EXECUTED
4000e174: 90 05 ff ff add %l7, -1, %o0 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e178: 82 20 00 17 neg %l7, %g1 <== NOT EXECUTED
4000e17c: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
4000e180: 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));
4000e184: 90 02 00 1c add %o0, %i4, %o0 <== NOT EXECUTED
4000e188: 7f ff d1 3b call 40002674 <.udiv> <== NOT EXECUTED
4000e18c: 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)) ||
4000e190: 80 a7 60 01 cmp %i5, 1 <== NOT EXECUTED
4000e194: 02 80 00 54 be 4000e2e4 <msdos_format+0xc9c> <== NOT EXECUTED
4000e198: b0 24 00 08 sub %l0, %o0, %i0 <== NOT EXECUTED
4000e19c: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000e1a0: 02 80 00 62 be 4000e328 <msdos_format+0xce0> <== NOT EXECUTED
4000e1a4: 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)
4000e1a8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4000e1ac: 7f ff d0 f8 call 4000258c <.umul> <== NOT EXECUTED
4000e1b0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e1b4: 07 00 00 20 sethi %hi(0x8000), %g3 <== NOT EXECUTED
4000e1b8: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED
4000e1bc: 08 80 00 57 bleu 4000e318 <msdos_format+0xcd0> <== NOT EXECUTED
4000e1c0: 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;
4000e1c4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000e1c8: 7f ff d1 2b call 40002674 <.udiv> <== NOT EXECUTED
4000e1cc: 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 =
4000e1d0: 09 10 00 b2 sethi %hi(0x4002c800), %g4 <== NOT EXECUTED
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000e1d4: 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 =
4000e1d8: d0 01 23 f8 ld [ %g4 + 0x3f8 ], %o0 <== NOT EXECUTED
4000e1dc: 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;
4000e1e0: 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 =
4000e1e4: 7f ff d1 24 call 40002674 <.udiv> <== NOT EXECUTED
4000e1e8: 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
4000e1ec: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
4000e1f0: 1a 80 00 69 bcc 4000e394 <msdos_format+0xd4c> <== NOT EXECUTED
4000e1f4: 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 =
4000e1f8: 03 10 00 b2 sethi %hi(0x4002c800), %g1 <== NOT EXECUTED
4000e1fc: d0 00 63 fc ld [ %g1 + 0x3fc ], %o0 ! 4002cbfc <_CPU_Trap_slot_template+0x18c><== NOT EXECUTED
4000e200: 7f ff d1 1d call 40002674 <.udiv> <== NOT EXECUTED
4000e204: 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
4000e208: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
4000e20c: 2a 80 00 07 bcs,a 4000e228 <msdos_format+0xbe0> <== NOT EXECUTED
4000e210: 84 10 20 04 mov 4, %g2 <== NOT EXECUTED
4000e214: 07 00 00 3f sethi %hi(0xfc00), %g3 <== NOT EXECUTED
4000e218: 86 10 e3 f4 or %g3, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
4000e21c: 80 a0 c0 10 cmp %g3, %l0 <== NOT EXECUTED
4000e220: 0a 80 00 2f bcs 4000e2dc <msdos_format+0xc94> <== NOT EXECUTED
4000e224: 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) {
4000e228: 82 08 a0 ff and %g2, 0xff, %g1 <== NOT EXECUTED
4000e22c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000e230: 02 80 00 5f be 4000e3ac <msdos_format+0xd64> <== NOT EXECUTED
4000e234: 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 ) {
4000e238: 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
4000e23c: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
4000e240: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED
4000e244: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
4000e248: 18 80 00 06 bgu 4000e260 <msdos_format+0xc18> <== NOT EXECUTED
4000e24c: 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;
4000e250: 10 80 01 16 b 4000e6a8 <msdos_format+0x1060> <== NOT EXECUTED
4000e254: 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-- ) {
4000e258: 02 80 00 07 be 4000e274 <msdos_format+0xc2c> <== NOT EXECUTED
4000e25c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if ( (gigs & ( 1 << b) ) != 0 )
4000e260: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
4000e264: 85 29 00 01 sll %g4, %g1, %g2 <== NOT EXECUTED
4000e268: 80 88 80 03 btst %g2, %g3 <== NOT EXECUTED
4000e26c: 02 bf ff fb be 4000e258 <msdos_format+0xc10> <== NOT EXECUTED
4000e270: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
}
fmt_params->sectors_per_cluster = 1 << b;
4000e274: 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,
4000e278: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e27c: 7f ff fc d2 call 4000d5c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000e280: 92 07 bd ac add %fp, -596, %o1 <== NOT EXECUTED
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
4000e284: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
4000e288: 84 08 60 ff and %g1, 0xff, %g2 <== NOT EXECUTED
4000e28c: 80 a7 40 02 cmp %i5, %g2 <== NOT EXECUTED
4000e290: 02 80 00 08 be 4000e2b0 <msdos_format+0xc68> <== NOT EXECUTED
4000e294: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000e298: 84 0c e0 ff and %l3, 0xff, %g2 <== NOT EXECUTED
4000e29c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
4000e2a0: 08 80 00 05 bleu 4000e2b4 <msdos_format+0xc6c> <== NOT EXECUTED
4000e2a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
--fmt_params->totl_sector_cnt;
4000e2a8: aa 05 7f ff add %l5, -1, %l5 <== NOT EXECUTED
4000e2ac: 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
4000e2b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e2b4: 12 80 00 b6 bne 4000e58c <msdos_format+0xf44> <== NOT EXECUTED
4000e2b8: a6 04 e0 01 inc %l3 <== NOT EXECUTED
&& fmt_params->fattype != fat_type
4000e2bc: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
4000e2c0: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000e2c4: 02 80 00 3a be 4000e3ac <msdos_format+0xd64> <== NOT EXECUTED
4000e2c8: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
&& fmt_params->totl_sector_cnt > 0 ) {
4000e2cc: 12 bf ff 50 bne 4000e00c <msdos_format+0x9c4> <== NOT EXECUTED
4000e2d0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4000e2d4: 10 bf fe ea b 4000de7c <msdos_format+0x834> <== NOT EXECUTED
4000e2d8: 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;
4000e2dc: 10 bf ff d3 b 4000e228 <msdos_format+0xbe0> <== NOT EXECUTED
4000e2e0: 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)) ||
4000e2e4: 80 a6 2f f5 cmp %i0, 0xff5 <== NOT EXECUTED
4000e2e8: 08 80 00 04 bleu 4000e2f8 <msdos_format+0xcb0> <== NOT EXECUTED
4000e2ec: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
4000e2f0: af 2d e0 01 sll %l7, 1, %l7 <== NOT EXECUTED
4000e2f4: 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)) {
4000e2f8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4000e2fc: 7f ff d0 a4 call 4000258c <.umul> <== NOT EXECUTED
4000e300: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e304: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
4000e308: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED
4000e30c: 38 bf ff af bgu,a 4000e1c8 <msdos_format+0xb80> <== NOT EXECUTED
4000e310: 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);
4000e314: 80 8c 20 ff btst 0xff, %l0 <== NOT EXECUTED
4000e318: 02 bf ff 79 be 4000e0fc <msdos_format+0xab4> <== NOT EXECUTED
4000e31c: 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;
4000e320: 10 bf ff aa b 4000e1c8 <msdos_format+0xb80> <== NOT EXECUTED
4000e324: 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))) {
4000e328: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED
4000e32c: 82 10 63 f5 or %g1, 0x3f5, %g1 ! fff5 <PROM_START+0xfff5> <== NOT EXECUTED
4000e330: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
4000e334: 08 bf ff 9e bleu 4000e1ac <msdos_format+0xb64> <== NOT EXECUTED
4000e338: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
sectors_per_cluster *= 2;
4000e33c: af 2d e0 01 sll %l7, 1, %l7 <== NOT EXECUTED
4000e340: 10 bf ff 9a b 4000e1a8 <msdos_format+0xb60> <== NOT EXECUTED
4000e344: 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);
4000e348: c6 07 bd 48 ld [ %fp + -696 ], %g3 <== NOT EXECUTED
4000e34c: 84 00 c0 17 add %g3, %l7, %g2 <== NOT EXECUTED
4000e350: 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;
4000e354: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
4000e358: 7f ff d0 c7 call 40002674 <.udiv> <== NOT EXECUTED
4000e35c: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
4000e360: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 3 / 2;
4000e364: 91 2a 20 01 sll %o0, 1, %o0 <== NOT EXECUTED
4000e368: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
4000e36c: 10 bf ff 7a b 4000e154 <msdos_format+0xb0c> <== NOT EXECUTED
4000e370: 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);
4000e374: 84 01 00 17 add %g4, %l7, %g2 <== NOT EXECUTED
4000e378: 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;
4000e37c: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
4000e380: 7f ff d0 bd call 40002674 <.udiv> <== NOT EXECUTED
4000e384: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
4000e388: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
4000e38c: 10 bf ff 72 b 4000e154 <msdos_format+0xb0c> <== NOT EXECUTED
4000e390: 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
4000e394: 18 bf ff 99 bgu 4000e1f8 <msdos_format+0xbb0> <== NOT EXECUTED
4000e398: 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) {
4000e39c: 82 08 a0 ff and %g2, 0xff, %g1 <== NOT EXECUTED
4000e3a0: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000e3a4: 12 bf ff a5 bne 4000e238 <msdos_format+0xbf0> <== NOT EXECUTED
4000e3a8: c4 2f bd de stb %g2, [ %fp + -546 ] <== NOT EXECUTED
4000e3ac: f6 07 bd 40 ld [ %fp + -704 ], %i3 <== NOT EXECUTED
4000e3b0: ee 07 bd 3c ld [ %fp + -708 ], %l7 <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000e3b4: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
4000e3b8: 02 bf fe b1 be 4000de7c <msdos_format+0x834> <== NOT EXECUTED
4000e3bc: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
ret_val = -1;
}
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
4000e3c0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000e3c4: 02 80 00 8b be 4000e5f0 <msdos_format+0xfa8> <== NOT EXECUTED
4000e3c8: 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)
4000e3cc: f8 0f bd fc ldub [ %fp + -516 ], %i4 <== NOT EXECUTED
4000e3d0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000e3d4: 12 80 00 06 bne 4000e3ec <msdos_format+0xda4> <== NOT EXECUTED
4000e3d8: f4 07 bd b8 ld [ %fp + -584 ], %i2 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e3dc: 90 02 00 1a add %o0, %i2, %o0 <== NOT EXECUTED
4000e3e0: 82 20 00 1a neg %i2, %g1 <== NOT EXECUTED
4000e3e4: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
4000e3e8: 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);
4000e3ec: d2 07 bd ac ld [ %fp + -596 ], %o1 <== NOT EXECUTED
4000e3f0: 7f ff d0 67 call 4000258c <.umul> <== NOT EXECUTED
4000e3f4: 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,
4000e3f8: 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)
4000e3fc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000e400: 12 80 00 06 bne 4000e418 <msdos_format+0xdd0> <== NOT EXECUTED
4000e404: fa 07 bd b4 ld [ %fp + -588 ], %i5 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000e408: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
4000e40c: 82 20 00 1a neg %i2, %g1 <== NOT EXECUTED
4000e410: ba 07 40 1a add %i5, %i2, %i5 <== NOT EXECUTED
4000e414: ba 0f 40 01 and %i5, %g1, %i5 <== NOT EXECUTED
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000e418: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000e41c: 02 80 00 26 be 4000e4b4 <msdos_format+0xe6c> <== NOT EXECUTED
4000e420: fa 27 bd b4 st %i5, [ %fp + -588 ] <== NOT EXECUTED
(rqdata->media != 0)) {
4000e424: f8 0e 60 14 ldub [ %i1 + 0x14 ], %i4 <== NOT EXECUTED
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000e428: b4 8f 20 ff andcc %i4, 0xff, %i2 <== NOT EXECUTED
4000e42c: 02 80 00 23 be 4000e4b8 <msdos_format+0xe70> <== NOT EXECUTED
4000e430: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
(rqdata->media != 0)) {
const char valid_media_codes[] =
4000e434: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
4000e438: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
4000e43c: 13 10 00 b2 sethi %hi(0x4002c800), %o1 <== NOT EXECUTED
4000e440: 40 00 3a 79 call 4001ce24 <memcpy> <== NOT EXECUTED
4000e444: 92 12 63 e8 or %o1, 0x3e8, %o1 ! 4002cbe8 <_CPU_Trap_slot_template+0x178><== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
4000e448: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
4000e44c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4000e450: 40 00 3a 07 call 4001cc6c <memchr> <== NOT EXECUTED
4000e454: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
4000e458: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e45c: 02 80 00 b2 be 4000e724 <msdos_format+0x10dc> <== NOT EXECUTED
4000e460: 01 00 00 00 nop <== NOT EXECUTED
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
4000e464: f8 2f bd dd stb %i4, [ %fp + -547 ] <== NOT EXECUTED
4000e468: 10 bf fc c3 b 4000d774 <msdos_format+0x12c> <== NOT EXECUTED
4000e46c: 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) {
4000e470: 82 1f 60 02 xor %i5, 2, %g1 <== NOT EXECUTED
4000e474: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4000e478: 90 40 3f ff addx %g0, -1, %o0 <== NOT EXECUTED
4000e47c: 90 0a 21 c0 and %o0, 0x1c0, %o0 <== NOT EXECUTED
4000e480: 10 bf fe f9 b 4000e064 <msdos_format+0xa1c> <== NOT EXECUTED
4000e484: 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;
4000e488: 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;
4000e48c: 84 10 20 06 mov 6, %g2 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4000e490: 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;
4000e494: 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;
4000e498: c0 27 bd c4 clr [ %fp + -572 ] <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4000e49c: c4 27 bd d4 st %g2, [ %fp + -556 ] <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4000e4a0: c6 27 bd d8 st %g3, [ %fp + -552 ] <== NOT EXECUTED
4000e4a4: f6 07 bd ac ld [ %fp + -596 ], %i3 <== NOT EXECUTED
4000e4a8: a8 10 20 20 mov 0x20, %l4 <== NOT EXECUTED
4000e4ac: 10 bf fe f8 b 4000e08c <msdos_format+0xa44> <== NOT EXECUTED
4000e4b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000e4b4: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
4000e4b8: f8 0f bd 57 ldub [ %fp + -681 ], %i4 <== NOT EXECUTED
4000e4bc: 10 bf fc ae b 4000d774 <msdos_format+0x12c> <== NOT EXECUTED
4000e4c0: 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) {
4000e4c4: 89 28 60 0e sll %g1, 0xe, %g4 <== NOT EXECUTED
4000e4c8: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
4000e4cc: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED
4000e4d0: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED
4000e4d4: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
4000e4d8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000e4dc: 2a 80 00 1f bcs,a 4000e558 <msdos_format+0xf10> <== NOT EXECUTED
4000e4e0: 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;
4000e4e4: 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;
4000e4e8: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000e4ec: 1b 10 00 00 sethi %hi(0x40000000), %o5 <== NOT EXECUTED
4000e4f0: 86 87 40 0d addcc %i5, %o5, %g3 <== NOT EXECUTED
4000e4f4: 84 47 00 0c addx %i4, %o4, %g2 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
4000e4f8: 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;
4000e4fc: 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--)
4000e500: 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;
4000e504: 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)
4000e508: 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;
4000e50c: 10 80 00 04 b 4000e51c <msdos_format+0xed4> <== NOT EXECUTED
4000e510: 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--)
4000e514: 02 80 00 67 be 4000e6b0 <msdos_format+0x1068> <== NOT EXECUTED
4000e518: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4000e51c: 85 28 c0 01 sll %g3, %g1, %g2 <== NOT EXECUTED
4000e520: 80 88 80 04 btst %g2, %g4 <== NOT EXECUTED
4000e524: 02 bf ff fc be 4000e514 <msdos_format+0xecc> <== NOT EXECUTED
4000e528: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
fmt_params->sectors_per_cluster = 1 << b;
4000e52c: 10 bf fe 9d b 4000dfa0 <msdos_format+0x958> <== NOT EXECUTED
4000e530: 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;
4000e534: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
4000e538: 10 bf fe 92 b 4000df80 <msdos_format+0x938> <== NOT EXECUTED
4000e53c: 86 10 e3 a8 or %g3, 0x3a8, %g3 <== NOT EXECUTED
4000e540: 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) {
4000e544: a2 10 20 00 clr %l1 <== NOT EXECUTED
4000e548: a4 10 20 00 clr %l2 <== NOT EXECUTED
4000e54c: a6 10 20 00 clr %l3 <== NOT EXECUTED
4000e550: 10 bf fd 0c b 4000d980 <msdos_format+0x338> <== NOT EXECUTED
4000e554: 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;
4000e558: c2 2f bd de stb %g1, [ %fp + -546 ] <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000e55c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
4000e560: 10 bf fe 90 b 4000dfa0 <msdos_format+0x958> <== NOT EXECUTED
4000e564: 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;
4000e568: 40 00 37 8a call 4001c390 <__errno> <== NOT EXECUTED
4000e56c: 01 00 00 00 nop <== NOT EXECUTED
4000e570: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
ret_val = -1;
4000e574: 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;
4000e578: 10 bf fc 75 b 4000d74c <msdos_format+0x104> <== NOT EXECUTED
4000e57c: 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),
4000e580: 03 10 00 b2 sethi %hi(0x4002c800), %g1 <== NOT EXECUTED
4000e584: 10 bf fd 3f b 4000da80 <msdos_format+0x438> <== NOT EXECUTED
4000e588: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 4002cab0 <_CPU_Trap_slot_template+0x40><== NOT EXECUTED
4000e58c: f6 07 bd 40 ld [ %fp + -704 ], %i3 <== NOT EXECUTED
4000e590: 10 bf fc 73 b 4000d75c <msdos_format+0x114> <== NOT EXECUTED
4000e594: 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();
4000e598: 40 00 3c df call 4001d914 <rand> <== NOT EXECUTED
4000e59c: 01 00 00 00 nop <== NOT EXECUTED
4000e5a0: 10 bf fc c5 b 4000d8b4 <msdos_format+0x26c> <== NOT EXECUTED
4000e5a4: 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,
4000e5a8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e5ac: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000e5b0: 7f ff fb 6b call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000e5b4: 94 12 a3 90 or %o2, 0x390, %o2 ! 4002cb90 <_CPU_Trap_slot_template+0x120><== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000e5b8: d2 07 bd d4 ld [ %fp + -556 ], %o1 <== NOT EXECUTED
4000e5bc: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
4000e5c0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000e5c4: 7f ff fb 7b call 4000d3b0 <msdos_format_write_sec> <== NOT EXECUTED
4000e5c8: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000e5cc: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000e5d0: 02 bf fd 4f be 4000db0c <msdos_format+0x4c4> <== NOT EXECUTED
4000e5d4: 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) {
4000e5d8: 10 bf fc 4c b 4000d708 <msdos_format+0xc0> <== NOT EXECUTED
4000e5dc: 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 */
4000e5e0: 10 bf fc 79 b 4000d7c4 <msdos_format+0x17c> <== NOT EXECUTED
4000e5e4: 88 11 22 d0 or %g4, 0x2d0, %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 */
4000e5e8: 10 bf fc 97 b 4000d844 <msdos_format+0x1fc> <== NOT EXECUTED
4000e5ec: 88 11 21 30 or %g4, 0x130, %g4 <== NOT EXECUTED
4000e5f0: f4 07 bd b8 ld [ %fp + -584 ], %i2 <== NOT EXECUTED
4000e5f4: 10 bf ff 82 b 4000e3fc <msdos_format+0xdb4> <== NOT EXECUTED
4000e5f8: 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);
4000e5fc: 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 */
4000e600: 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);
4000e604: b1 30 60 08 srl %g1, 8, %i0 <== NOT EXECUTED
4000e608: bb 30 60 10 srl %g1, 0x10, %i5 <== NOT EXECUTED
4000e60c: 89 30 60 18 srl %g1, 0x18, %g4 <== NOT EXECUTED
4000e610: 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);
4000e614: 82 10 20 29 mov 0x29, %g1 <== NOT EXECUTED
4000e618: 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),
4000e61c: 03 00 00 11 sethi %hi(0x4400), %g1 <== NOT EXECUTED
4000e620: 82 10 62 41 or %g1, 0x241, %g1 ! 4641 <PROM_START+0x4641> <== NOT EXECUTED
4000e624: c2 37 be 52 sth %g1, [ %fp + -430 ] <== NOT EXECUTED
4000e628: 03 00 00 15 sethi %hi(0x5400), %g1 <== NOT EXECUTED
4000e62c: 82 10 60 33 or %g1, 0x33, %g1 ! 5433 <PROM_START+0x5433> <== NOT EXECUTED
4000e630: c2 37 be 54 sth %g1, [ %fp + -428 ] <== NOT EXECUTED
4000e634: 03 00 00 0c sethi %hi(0x3000), %g1 <== NOT EXECUTED
4000e638: 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 */
4000e63c: 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),
4000e640: 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);
4000e644: 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),
4000e648: 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);
4000e64c: 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),
4000e650: 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);
4000e654: 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 */
4000e658: 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*/
4000e65c: 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 */
4000e660: c4 2f be 32 stb %g2, [ %fp + -462 ] <== NOT EXECUTED
4000e664: c6 2f be 33 stb %g3, [ %fp + -461 ] <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4000e668: c0 27 be 34 clr [ %fp + -460 ] <== NOT EXECUTED
4000e66c: c0 27 be 38 clr [ %fp + -456 ] <== NOT EXECUTED
4000e670: 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);
4000e674: c0 2f be 47 clrb [ %fp + -441 ] <== NOT EXECUTED
4000e678: c0 2f be 48 clrb [ %fp + -440 ] <== NOT EXECUTED
4000e67c: c0 2f be 49 clrb [ %fp + -439 ] <== NOT EXECUTED
4000e680: c0 2f be 4a clrb [ %fp + -438 ] <== NOT EXECUTED
4000e684: c0 2f be 4b clrb [ %fp + -437 ] <== NOT EXECUTED
4000e688: c0 2f be 4c clrb [ %fp + -436 ] <== NOT EXECUTED
4000e68c: c0 2f be 4d clrb [ %fp + -435 ] <== NOT EXECUTED
4000e690: c0 2f be 4e clrb [ %fp + -434 ] <== NOT EXECUTED
4000e694: c0 2f be 4f clrb [ %fp + -433 ] <== NOT EXECUTED
4000e698: c0 2f be 50 clrb [ %fp + -432 ] <== NOT EXECUTED
4000e69c: c0 2f be 51 clrb [ %fp + -431 ] <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000e6a0: 10 bf fd 00 b 4000daa0 <msdos_format+0x458> <== NOT EXECUTED
4000e6a4: 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;
4000e6a8: 10 bf fe f4 b 4000e278 <msdos_format+0xc30> <== NOT EXECUTED
4000e6ac: 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;
4000e6b0: 10 bf fe 3c b 4000dfa0 <msdos_format+0x958> <== NOT EXECUTED
4000e6b4: c4 27 bd b8 st %g2, [ %fp + -584 ] <== NOT EXECUTED
4000e6b8: c6 0f bd 57 ldub [ %fp + -681 ], %g3 <== NOT EXECUTED
4000e6bc: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000e6c0: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
4000e6c4: 10 bf fd 66 b 4000dc5c <msdos_format+0x614> <== NOT EXECUTED
4000e6c8: 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,
4000e6cc: 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;
4000e6d0: 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,
4000e6d4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000e6d8: 96 10 20 02 mov 2, %o3 <== NOT EXECUTED
4000e6dc: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000e6e0: 7f ff fb 1f call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000e6e4: 94 12 a3 28 or %o2, 0x328, %o2 ! 4002cb28 <_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;
4000e6e8: 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;
4000e6ec: 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;
4000e6f0: 10 bf fe 24 b 4000df80 <msdos_format+0x938> <== NOT EXECUTED
4000e6f4: 86 10 e3 a8 or %g3, 0x3a8, %g3 <== NOT EXECUTED
4000e6f8: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000e6fc: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000e700: 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
4000e704: 84 10 00 17 mov %l7, %g2 <== NOT EXECUTED
4000e708: 10 bf fc 15 b 4000d75c <msdos_format+0x114> <== NOT EXECUTED
4000e70c: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
4000e710: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000e714: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000e718: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000e71c: 10 bf ff 26 b 4000e3b4 <msdos_format+0xd6c> <== NOT EXECUTED
4000e720: 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;
4000e724: 40 00 37 1b call 4001c390 <__errno> <== NOT EXECUTED
4000e728: b8 10 20 00 clr %i4 <== NOT EXECUTED
4000e72c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000e730: fa 07 bd b4 ld [ %fp + -588 ], %i5 <== NOT EXECUTED
4000e734: 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;
4000e738: 10 bf fc 0f b 4000d774 <msdos_format+0x12c> <== NOT EXECUTED
4000e73c: 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;
4000e740: 10 bf ff 05 b 4000e354 <msdos_format+0xd0c> <== NOT EXECUTED
4000e744: c2 07 bd 4c ld [ %fp + -692 ], %g1 <== NOT EXECUTED
4000d410 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000d410: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4000d414: 90 10 00 1c mov %i4, %o0
4000d418: 7f ff df 38 call 400050f8 <malloc>
4000d41c: a6 10 00 18 mov %i0, %l3
if (fill_buffer == NULL) {
4000d420: 80 a2 20 00 cmp %o0, 0
4000d424: 02 80 00 47 be 4000d540 <msdos_format_fill_sectors+0x130> <== NEVER TAKEN
4000d428: a4 10 00 08 mov %o0, %l2
errno = ENOMEM;
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
4000d42c: 92 10 00 1d mov %i5, %o1
4000d430: 40 00 3e ba call 4001cf18 <memset>
4000d434: 94 10 00 1c mov %i4, %o2
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000d438: 90 10 00 18 mov %i0, %o0
4000d43c: 92 10 20 02 mov 2, %o1
4000d440: 15 10 00 b2 sethi %hi(0x4002c800), %o2
4000d444: 7f ff ff c6 call 4000d35c <msdos_format_printf>
4000d448: 94 12 a2 80 or %o2, 0x280, %o2 ! 4002ca80 <_CPU_Trap_slot_template+0x10>
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000d44c: 80 a6 e0 00 cmp %i3, 0
4000d450: 02 80 00 56 be 4000d5a8 <msdos_format_fill_sectors+0x198> <== NEVER TAKEN
4000d454: 83 2e e0 04 sll %i3, 4, %g1
4000d458: 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, ".");
4000d45c: 29 10 00 b2 sethi %hi(0x4002c800), %l4
4000d460: 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) &&
4000d464: a0 10 00 1b mov %i3, %l0
4000d468: 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;
4000d46c: a2 10 3f ff mov -1, %l1
4000d470: 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, ".");
4000d474: 10 80 00 10 b 4000d4b4 <msdos_format_fill_sectors+0xa4>
4000d478: a8 15 20 28 or %l4, 0x28, %l4
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000d47c: 92 10 00 1a mov %i2, %o1
4000d480: 90 10 00 19 mov %i1, %o0
4000d484: 94 10 00 1c mov %i4, %o2
4000d488: 96 10 00 12 mov %l2, %o3
4000d48c: 7f ff ff c9 call 4000d3b0 <msdos_format_write_sec>
4000d490: a0 04 3f ff add %l0, -1, %l0
start_sector++;
4000d494: 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);
4000d498: 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) &&
4000d49c: 80 a2 20 00 cmp %o0, 0
4000d4a0: 12 80 00 1c bne 4000d510 <msdos_format_fill_sectors+0x100><== NEVER TAKEN
4000d4a4: ba 07 7f 9c add %i5, -100, %i5
4000d4a8: 80 a4 20 00 cmp %l0, 0
4000d4ac: 02 80 00 1a be 4000d514 <msdos_format_fill_sectors+0x104>
4000d4b0: 90 10 00 13 mov %l3, %o0
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
4000d4b4: 92 10 00 1b mov %i3, %o1
4000d4b8: 7f ff d4 6f call 40002674 <.udiv>
4000d4bc: 90 10 00 1d mov %i5, %o0
if (percent != last_percent) {
4000d4c0: 80 a2 00 11 cmp %o0, %l1
4000d4c4: 02 bf ff ee be 4000d47c <msdos_format_fill_sectors+0x6c>
4000d4c8: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
4000d4cc: 12 bf ff ec bne 4000d47c <msdos_format_fill_sectors+0x6c>
4000d4d0: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000d4d4: 90 10 00 13 mov %l3, %o0
4000d4d8: 92 10 20 02 mov 2, %o1
4000d4dc: 7f ff ff a0 call 4000d35c <msdos_format_printf>
4000d4e0: 94 10 00 14 mov %l4, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000d4e4: 92 10 00 1a mov %i2, %o1
4000d4e8: 90 10 00 19 mov %i1, %o0
4000d4ec: 94 10 00 1c mov %i4, %o2
4000d4f0: 96 10 00 12 mov %l2, %o3
4000d4f4: 7f ff ff af call 4000d3b0 <msdos_format_write_sec>
4000d4f8: a0 04 3f ff add %l0, -1, %l0
start_sector++;
4000d4fc: 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);
4000d500: 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) &&
4000d504: 80 a2 20 00 cmp %o0, 0
4000d508: 02 bf ff e8 be 4000d4a8 <msdos_format_fill_sectors+0x98> <== ALWAYS TAKEN
4000d50c: 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");
4000d510: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000d514: 92 10 20 02 mov 2, %o1
4000d518: 15 10 00 b2 sethi %hi(0x4002c800), %o2
4000d51c: 7f ff ff 90 call 4000d35c <msdos_format_printf>
4000d520: 94 12 a3 88 or %o2, 0x388, %o2 ! 4002cb88 <_CPU_Trap_slot_template+0x118>
if (ret_val)
4000d524: 80 a6 20 00 cmp %i0, 0
4000d528: 12 80 00 16 bne 4000d580 <msdos_format_fill_sectors+0x170><== NEVER TAKEN
4000d52c: 90 10 00 13 mov %l3, %o0
/*
* cleanup
*/
if (fill_buffer != NULL) {
free(fill_buffer);
4000d530: 7f ff dd 9f call 40004bac <free>
4000d534: 90 10 00 12 mov %l2, %o0
4000d538: 81 c7 e0 08 ret
4000d53c: 81 e8 00 00 restore
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
4000d540: 40 00 3b 94 call 4001c390 <__errno> <== NOT EXECUTED
4000d544: 01 00 00 00 nop <== NOT EXECUTED
4000d548: 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,
4000d54c: 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;
4000d550: 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,
4000d554: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d558: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d55c: 7f ff ff 80 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d560: 94 12 a2 80 or %o2, 0x280, %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");
4000d564: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d568: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d56c: 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;
4000d570: 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");
4000d574: 7f ff ff 7a call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d578: 94 12 a3 88 or %o2, 0x388, %o2 <== NOT EXECUTED
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000d57c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000d580: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000d584: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4000d588: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d58c: 7f ff ff 74 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d590: 94 12 a2 90 or %o2, 0x290, %o2 ! 4002ca90 <_CPU_Trap_slot_template+0x20><== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
4000d594: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4000d598: 12 bf ff e6 bne 4000d530 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
4000d59c: 01 00 00 00 nop <== NOT EXECUTED
free(fill_buffer);
fill_buffer = NULL;
}
return ret_val;
}
4000d5a0: 81 c7 e0 08 ret <== NOT EXECUTED
4000d5a4: 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");
4000d5a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d5ac: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
4000d5b0: 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");
4000d5b4: 15 10 00 b2 sethi %hi(0x4002c800), %o2 <== NOT EXECUTED
4000d5b8: 7f ff ff 69 call 4000d35c <msdos_format_printf> <== NOT EXECUTED
4000d5bc: 94 12 a3 88 or %o2, 0x388, %o2 ! 4002cb88 <_CPU_Trap_slot_template+0x118><== NOT EXECUTED
4000d5c0: 30 bf ff dc b,a 4000d530 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
4000d35c <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
4000d35c: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
4000d360: 94 07 a0 50 add %fp, 0x50, %o2
4000d364: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000d368: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000d36c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
4000d370: 80 a6 20 00 cmp %i0, 0
4000d374: 02 80 00 0d be 4000d3a8 <msdos_format_printf+0x4c>
4000d378: d4 27 bf fc st %o2, [ %fp + -4 ]
4000d37c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000d380: 80 a0 40 19 cmp %g1, %i1
4000d384: 06 80 00 09 bl 4000d3a8 <msdos_format_printf+0x4c> <== ALWAYS TAKEN
4000d388: 3b 10 00 b6 sethi %hi(0x4002d800), %i5
{
vfprintf (stdout, format, args);
4000d38c: c2 07 63 48 ld [ %i5 + 0x348 ], %g1 ! 4002db48 <_impure_ptr><== NOT EXECUTED
4000d390: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4000d394: 40 00 5d 0c call 400247c4 <vfprintf> <== NOT EXECUTED
4000d398: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
4000d39c: c2 07 63 48 ld [ %i5 + 0x348 ], %g1 <== NOT EXECUTED
4000d3a0: 40 00 3c ff call 4001c79c <fflush> <== NOT EXECUTED
4000d3a4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
4000d3a8: 81 c7 e0 08 ret
4000d3ac: 81 e8 00 00 restore
4000d3b0 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000d3b0: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000d3b4: 94 10 20 00 clr %o2
4000d3b8: 96 10 00 1a mov %i2, %o3
4000d3bc: 90 10 20 00 clr %o0
4000d3c0: 7f ff d3 56 call 40002118 <__muldi3>
4000d3c4: 92 10 00 19 mov %i1, %o1
4000d3c8: 84 10 00 08 mov %o0, %g2
4000d3cc: 86 10 00 09 mov %o1, %g3
4000d3d0: 90 10 00 18 mov %i0, %o0
4000d3d4: 92 10 00 02 mov %g2, %o1
4000d3d8: 94 10 00 03 mov %g3, %o2
4000d3dc: 40 00 1f 49 call 40015100 <lseek>
4000d3e0: 96 10 20 00 clr %o3
4000d3e4: 80 a2 20 00 cmp %o0, 0
4000d3e8: 16 80 00 04 bge 4000d3f8 <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
4000d3ec: 90 10 00 18 mov %i0, %o0
4000d3f0: 81 c7 e0 08 ret <== NOT EXECUTED
4000d3f4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
4000d3f8: 92 10 00 1b mov %i3, %o1
4000d3fc: 7f ff ee 0f call 40008c38 <write>
4000d400: 94 10 00 1a mov %i2, %o2
4000d404: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
4000d408: 81 c7 e0 08 ret
4000d40c: 81 e8 00 00 restore
400199a4 <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
)
{
400199a4: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
400199a8: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
400199ac: 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);
400199b0: 90 10 00 1c mov %i4, %o0
400199b4: 92 10 00 1a mov %i2, %o1
400199b8: 7f ff e2 bc call 400124a8 <fat_file_open>
400199bc: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
400199c0: ba 92 20 00 orcc %o0, 0, %i5
400199c4: 02 80 00 04 be 400199d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x30><== ALWAYS TAKEN
400199c8: 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;
}
400199cc: 81 c7 e0 08 ret
400199d0: 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;
400199d4: 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;
400199d8: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
400199dc: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
400199e0: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
400199e4: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
400199e8: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400199ec: 7f ff e5 e5 call 40013180 <fat_file_size>
400199f0: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
400199f4: ba 92 20 00 orcc %o0, 0, %i5
400199f8: 12 80 00 95 bne 40019c4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
400199fc: 33 10 00 b2 sethi %hi(0x4002c800), %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);
40019a00: ba 07 bf c0 add %fp, -64, %i5
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
40019a04: 94 10 00 1d mov %i5, %o2
40019a08: 92 10 20 01 mov 1, %o1
40019a0c: 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);
40019a10: c0 27 bf c0 clr [ %fp + -64 ]
40019a14: c0 27 bf c4 clr [ %fp + -60 ]
40019a18: c0 27 bf c8 clr [ %fp + -56 ]
40019a1c: c0 27 bf cc clr [ %fp + -52 ]
40019a20: c0 27 bf d0 clr [ %fp + -48 ]
40019a24: c0 27 bf d4 clr [ %fp + -44 ]
40019a28: c0 27 bf d8 clr [ %fp + -40 ]
40019a2c: c0 27 bf dc clr [ %fp + -36 ]
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
40019a30: 7f ff fa eb call 400185dc <msdos_long_to_short>
40019a34: 90 16 60 28 or %i1, 0x28, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
40019a38: d2 07 bf bc ld [ %fp + -68 ], %o1
40019a3c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40019a40: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
40019a44: 90 10 00 18 mov %i0, %o0
40019a48: 94 10 20 00 clr %o2
40019a4c: 96 16 60 28 or %i1, 0x28, %o3
40019a50: 98 10 20 01 mov 1, %o4
40019a54: 7f ff fc da call 40018dbc <msdos_find_name_in_fat_file>
40019a58: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
40019a5c: ba 92 20 00 orcc %o0, 0, %i5
40019a60: 12 80 00 7b bne 40019c4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
40019a64: 33 10 00 b3 sethi %hi(0x4002cc00), %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);
40019a68: ba 07 bf e0 add %fp, -32, %i5
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
40019a6c: 94 10 00 1d mov %i5, %o2
40019a70: 92 10 20 02 mov 2, %o1
40019a74: 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);
40019a78: c0 27 bf e0 clr [ %fp + -32 ]
40019a7c: c0 27 bf e4 clr [ %fp + -28 ]
40019a80: c0 27 bf e8 clr [ %fp + -24 ]
40019a84: c0 27 bf ec clr [ %fp + -20 ]
40019a88: c0 27 bf f0 clr [ %fp + -16 ]
40019a8c: c0 27 bf f4 clr [ %fp + -12 ]
40019a90: c0 27 bf f8 clr [ %fp + -8 ]
40019a94: c0 27 bf fc clr [ %fp + -4 ]
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
40019a98: 7f ff fa d1 call 400185dc <msdos_long_to_short>
40019a9c: 90 16 62 b0 or %i1, 0x2b0, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
40019aa0: d2 07 bf bc ld [ %fp + -68 ], %o1
40019aa4: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40019aa8: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
40019aac: 90 10 00 18 mov %i0, %o0
40019ab0: 94 10 20 00 clr %o2
40019ab4: 96 16 62 b0 or %i1, 0x2b0, %o3
40019ab8: 98 10 20 02 mov 2, %o4
40019abc: 7f ff fc c0 call 40018dbc <msdos_find_name_in_fat_file>
40019ac0: 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);
40019ac4: 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)
40019ac8: 80 a2 20 00 cmp %o0, 0
40019acc: 12 80 00 66 bne 40019c64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
40019ad0: ba 10 00 08 mov %o0, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
40019ad4: f2 17 bf da lduh [ %fp + -38 ], %i1
40019ad8: e0 17 bf d4 lduh [ %fp + -44 ], %l0
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
40019adc: 7f ff e3 ed call 40012a90 <fat_file_close>
40019ae0: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
40019ae4: ba 92 20 00 orcc %o0, 0, %i5
40019ae8: 12 bf ff b9 bne 400199cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
40019aec: c4 17 bf fa lduh [ %fp + -6 ], %g2
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40019af0: c6 17 bf f4 lduh [ %fp + -12 ], %g3
40019af4: 85 28 a0 10 sll %g2, 0x10, %g2
40019af8: 87 28 e0 10 sll %g3, 0x10, %g3
40019afc: 89 30 a0 18 srl %g2, 0x18, %g4
40019b00: bb 30 e0 18 srl %g3, 0x18, %i5
40019b04: 03 00 00 3f sethi %hi(0xfc00), %g1
40019b08: 87 30 e0 08 srl %g3, 8, %g3
40019b0c: 82 10 63 ff or %g1, 0x3ff, %g1
40019b10: 85 30 a0 08 srl %g2, 8, %g2
40019b14: 86 08 c0 01 and %g3, %g1, %g3
40019b18: 82 08 80 01 and %g2, %g1, %g1
40019b1c: 86 17 40 03 or %i5, %g3, %g3
40019b20: 82 11 00 01 or %g4, %g1, %g1
40019b24: 87 28 e0 10 sll %g3, 0x10, %g3
40019b28: 80 90 c0 01 orcc %g3, %g1, %g0
40019b2c: 12 80 00 08 bne 40019b4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1a8><== ALWAYS TAKEN
40019b30: 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;
40019b34: 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;
40019b38: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40019b3c: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40019b40: 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;
40019b44: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40019b48: 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);
40019b4c: 92 10 00 1a mov %i2, %o1
40019b50: 7f ff e2 56 call 400124a8 <fat_file_open>
40019b54: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
40019b58: ba 92 20 00 orcc %o0, 0, %i5
40019b5c: 12 bf ff 9c bne 400199cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
40019b60: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40019b64: c8 17 bf fa lduh [ %fp + -6 ], %g4
40019b68: 83 28 60 10 sll %g1, 0x10, %g1
40019b6c: 07 00 00 3f sethi %hi(0xfc00), %g3
40019b70: 85 30 60 18 srl %g1, 0x18, %g2
40019b74: 86 10 e3 ff or %g3, 0x3ff, %g3
40019b78: 83 30 60 08 srl %g1, 8, %g1
40019b7c: 82 08 40 03 and %g1, %g3, %g1
40019b80: 89 29 20 10 sll %g4, 0x10, %g4
40019b84: 84 10 80 01 or %g2, %g1, %g2
40019b88: bb 31 20 18 srl %g4, 0x18, %i5
40019b8c: 85 28 a0 10 sll %g2, 0x10, %g2
40019b90: 89 31 20 08 srl %g4, 8, %g4
40019b94: 86 09 00 03 and %g4, %g3, %g3
40019b98: 82 17 40 03 or %i5, %g3, %g1
40019b9c: 82 90 80 01 orcc %g2, %g1, %g1
40019ba0: 12 80 00 35 bne 40019c74 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== ALWAYS TAKEN
40019ba4: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
40019ba8: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
40019bac: 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;
40019bb0: 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;
40019bb4: 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;
40019bb8: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
40019bbc: 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;
40019bc0: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
40019bc4: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
40019bc8: 7f ff e5 6e call 40013180 <fat_file_size>
40019bcc: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
40019bd0: 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)
40019bd4: 80 a2 20 00 cmp %o0, 0
40019bd8: 12 80 00 23 bne 40019c64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
40019bdc: ba 10 00 08 mov %o0, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
40019be0: a1 2c 20 10 sll %l0, 0x10, %l0
40019be4: b3 2e 60 10 sll %i1, 0x10, %i1
40019be8: 95 34 20 18 srl %l0, 0x18, %o2
40019bec: 85 36 60 18 srl %i1, 0x18, %g2
40019bf0: a1 34 20 08 srl %l0, 8, %l0
40019bf4: b3 36 60 08 srl %i1, 8, %i1
40019bf8: 03 00 00 3f sethi %hi(0xfc00), %g1
40019bfc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40019c00: a0 0c 00 01 and %l0, %g1, %l0
40019c04: 82 0e 40 01 and %i1, %g1, %g1
40019c08: 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,
40019c0c: 90 10 00 18 mov %i0, %o0
40019c10: 96 10 00 1a mov %i2, %o3
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
40019c14: 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,
40019c18: 98 10 00 1b mov %i3, %o4
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
40019c1c: 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,
40019c20: 7f ff fe fe call 40019818 <msdos_find_node_by_cluster_num_in_fat_file>
40019c24: 94 12 80 01 or %o2, %g1, %o2
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
40019c28: 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,
40019c2c: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
40019c30: 80 a7 60 00 cmp %i5, 0
40019c34: 12 80 00 12 bne 40019c7c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d8><== NEVER TAKEN
40019c38: 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);
40019c3c: 7f ff e3 95 call 40012a90 <fat_file_close>
40019c40: 01 00 00 00 nop
40019c44: 10 bf ff 62 b 400199cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28>
40019c48: 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);
40019c4c: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
40019c50: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40019c54: 7f ff e3 8f call 40012a90 <fat_file_close> <== NOT EXECUTED
40019c58: 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;
}
40019c5c: 81 c7 e0 08 ret <== NOT EXECUTED
40019c60: 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);
40019c64: 7f ff e3 8b call 40012a90 <fat_file_close> <== NOT EXECUTED
40019c68: 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;
}
40019c6c: 81 c7 e0 08 ret <== NOT EXECUTED
40019c70: 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);
40019c74: 10 bf ff cf b 40019bb0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c>
40019c78: 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);
40019c7c: 7f ff e3 85 call 40012a90 <fat_file_close> <== NOT EXECUTED
40019c80: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40019c84: 30 bf ff f6 b,a 40019c5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b8><== NOT EXECUTED
40019c88 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
40019c88: 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,
40019c8c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40019c90: 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
)
{
40019c94: 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,
40019c98: 9a 10 00 1c mov %i4, %o5
40019c9c: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
40019ca0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40019ca4: 94 10 00 19 mov %i1, %o2
40019ca8: 96 10 00 1a mov %i2, %o3
40019cac: 7f ff fc 44 call 40018dbc <msdos_find_name_in_fat_file>
40019cb0: 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))
40019cb4: 03 00 00 1f sethi %hi(0x7c00), %g1
40019cb8: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
40019cbc: 80 a2 00 01 cmp %o0, %g1
40019cc0: 12 80 00 2a bne 40019d68 <msdos_get_name_node+0xe0>
40019cc4: b8 10 00 08 mov %o0, %i4
return rc;
if (!create_node)
40019cc8: 80 a6 60 00 cmp %i1, 0
40019ccc: 12 80 00 25 bne 40019d60 <msdos_get_name_node+0xd8>
40019cd0: 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)
40019cd4: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
40019cd8: 80 a7 00 01 cmp %i4, %g1
40019cdc: 02 80 00 21 be 40019d60 <msdos_get_name_node+0xd8>
40019ce0: 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)
40019ce4: 12 80 00 1f bne 40019d60 <msdos_get_name_node+0xd8> <== NEVER TAKEN
40019ce8: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
40019cec: 94 10 20 02 mov 2, %o2
40019cf0: 13 10 00 b3 sethi %hi(0x4002cc00), %o1
40019cf4: 40 00 10 9c call 4001df64 <strncmp>
40019cf8: 92 12 62 b0 or %o1, 0x2b0, %o1 ! 4002ceb0 <IMFS_memfile_handlers+0x44>
40019cfc: 80 a2 20 00 cmp %o0, 0
40019d00: 12 80 00 18 bne 40019d60 <msdos_get_name_node+0xd8>
40019d04: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
40019d08: c2 14 20 14 lduh [ %l0 + 0x14 ], %g1
40019d0c: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
40019d10: 83 28 60 10 sll %g1, 0x10, %g1
40019d14: b3 30 60 18 srl %g1, 0x18, %i1
40019d18: 84 10 a3 ff or %g2, 0x3ff, %g2
40019d1c: 83 30 60 08 srl %g1, 8, %g1
40019d20: 82 08 40 02 and %g1, %g2, %g1
40019d24: 87 28 e0 10 sll %g3, 0x10, %g3
40019d28: b2 16 40 01 or %i1, %g1, %i1
40019d2c: 89 30 e0 18 srl %g3, 0x18, %g4
40019d30: b3 2e 60 10 sll %i1, 0x10, %i1
40019d34: 87 30 e0 08 srl %g3, 8, %g3
40019d38: 84 08 c0 02 and %g3, %g2, %g2
40019d3c: 82 11 00 02 or %g4, %g2, %g1
/* are we right under root dir ? */
if (dotdot_cln == 0)
40019d40: b2 96 40 01 orcc %i1, %g1, %i1
40019d44: 12 80 00 0e bne 40019d7c <msdos_get_name_node+0xf4>
40019d48: 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;
40019d4c: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40019d50: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40019d54: 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;
40019d58: 82 10 20 01 mov 1, %g1
40019d5c: c2 27 40 00 st %g1, [ %i5 ]
}
}
}
}
return rc;
}
40019d60: 81 c7 e0 08 ret
40019d64: 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))
40019d68: 80 a2 20 00 cmp %o0, 0
40019d6c: 02 bf ff d8 be 40019ccc <msdos_get_name_node+0x44>
40019d70: 80 a6 60 00 cmp %i1, 0
}
}
}
}
return rc;
}
40019d74: 81 c7 e0 08 ret
40019d78: 91 e8 00 1c restore %g0, %i4, %o0
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
40019d7c: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
40019d80: b4 10 00 1d mov %i5, %i2
40019d84: 7f ff ff 08 call 400199a4 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
40019d88: 97 e8 00 10 restore %g0, %l0, %o3
4000e7e4 <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
)
{
4000e7e4: 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));
4000e7e8: 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;
4000e7ec: 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));
4000e7f0: 7f ff d8 b8 call 40004ad0 <calloc>
4000e7f4: 92 10 20 a4 mov 0xa4, %o1
if (!fs_info)
4000e7f8: ba 92 20 00 orcc %o0, 0, %i5
4000e7fc: 02 80 00 58 be 4000e95c <msdos_initialize_support+0x178> <== NEVER TAKEN
4000e800: 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);
4000e804: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
4000e808: 40 00 14 42 call 40013910 <fat_init_volume_info>
4000e80c: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
4000e810: b8 92 20 00 orcc %o0, 0, %i4
4000e814: 12 80 00 34 bne 4000e8e4 <msdos_initialize_support+0x100> <== NEVER TAKEN
4000e818: 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;
4000e81c: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4000e820: 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;
4000e824: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
4000e828: f4 27 60 98 st %i2, [ %i5 + 0x98 ]
fs_info->directory_handlers = directory_handlers;
4000e82c: 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;
4000e830: 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);
4000e834: 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;
4000e838: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
4000e83c: 92 07 bf f0 add %fp, -16, %o1
4000e840: 40 00 0f 1a call 400124a8 <fat_file_open>
4000e844: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
4000e848: b8 92 20 00 orcc %o0, 0, %i4
4000e84c: 12 80 00 24 bne 4000e8dc <msdos_initialize_support+0xf8> <== NEVER TAKEN
4000e850: 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;
4000e854: 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;
4000e858: 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;
4000e85c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4000e860: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000e864: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
4000e868: 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 )
4000e86c: 80 a0 60 00 cmp %g1, 0
4000e870: 12 80 00 24 bne 4000e900 <msdos_initialize_support+0x11c>
4000e874: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4000e878: 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 :
4000e87c: 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) ?
4000e880: 80 a2 00 01 cmp %o0, %g1
4000e884: 0a 80 00 1d bcs 4000e8f8 <msdos_initialize_support+0x114>
4000e888: 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));
4000e88c: 7f ff d8 91 call 40004ad0 <calloc>
4000e890: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
4000e894: 80 a2 20 00 cmp %o0, 0
4000e898: 02 80 00 2a be 4000e940 <msdos_initialize_support+0x15c> <== NEVER TAKEN
4000e89c: 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,
4000e8a0: 90 10 20 03 mov 3, %o0
4000e8a4: 92 10 20 01 mov 1, %o1
4000e8a8: 94 10 20 10 mov 0x10, %o2
4000e8ac: 96 10 20 00 clr %o3
4000e8b0: 7f ff ea 2a call 40009158 <rtems_semaphore_create>
4000e8b4: 98 07 60 9c add %i5, 0x9c, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
4000e8b8: 80 a2 20 00 cmp %o0, 0
4000e8bc: 12 80 00 2d bne 4000e970 <msdos_initialize_support+0x18c> <== NEVER TAKEN
4000e8c0: 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;
4000e8c4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
4000e8c8: 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;
4000e8cc: c4 20 60 08 st %g2, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
4000e8d0: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
4000e8d4: 81 c7 e0 08 ret
4000e8d8: 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);
4000e8dc: 40 00 16 5c call 4001424c <fat_shutdown_drive> <== NOT EXECUTED
4000e8e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000e8e4: 7f ff d8 b2 call 40004bac <free> <== NOT EXECUTED
4000e8e8: 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;
}
4000e8ec: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4000e8f0: 81 c7 e0 08 ret <== NOT EXECUTED
4000e8f4: 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) ?
4000e8f8: 10 bf ff e5 b 4000e88c <msdos_initialize_support+0xa8>
4000e8fc: 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);
4000e900: 40 00 12 20 call 40013180 <fat_file_size>
4000e904: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
4000e908: 82 92 20 00 orcc %o0, 0, %g1
4000e90c: 12 80 00 04 bne 4000e91c <msdos_initialize_support+0x138> <== NEVER TAKEN
4000e910: 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;
4000e914: 10 bf ff de b 4000e88c <msdos_initialize_support+0xa8>
4000e918: 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);
4000e91c: 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);
4000e920: 40 00 10 5c call 40012a90 <fat_file_close> <== NOT EXECUTED
4000e924: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000e928: 40 00 16 49 call 4001424c <fat_shutdown_drive> <== NOT EXECUTED
4000e92c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000e930: 7f ff d8 9f call 40004bac <free> <== NOT EXECUTED
4000e934: 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;
}
4000e938: 81 c7 e0 08 ret <== NOT EXECUTED
4000e93c: 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);
4000e940: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000e944: 40 00 10 53 call 40012a90 <fat_file_close> <== NOT EXECUTED
4000e948: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000e94c: 40 00 16 40 call 4001424c <fat_shutdown_drive> <== NOT EXECUTED
4000e950: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000e954: 7f ff d8 96 call 40004bac <free> <== NOT EXECUTED
4000e958: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4000e95c: 40 00 36 8d call 4001c390 <__errno> <== NOT EXECUTED
4000e960: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
4000e964: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000e968: 10 bf ff e1 b 4000e8ec <msdos_initialize_support+0x108> <== NOT EXECUTED
4000e96c: 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);
4000e970: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000e974: 40 00 10 47 call 40012a90 <fat_file_close> <== NOT EXECUTED
4000e978: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000e97c: 40 00 16 34 call 4001424c <fat_shutdown_drive> <== NOT EXECUTED
4000e980: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
4000e984: d0 07 60 a0 ld [ %i5 + 0xa0 ], %o0 <== NOT EXECUTED
4000e988: 7f ff d8 89 call 40004bac <free> <== NOT EXECUTED
4000e98c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
free(fs_info);
4000e990: 7f ff d8 87 call 40004bac <free> <== NOT EXECUTED
4000e994: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4000e998: 40 00 36 7e call 4001c390 <__errno> <== NOT EXECUTED
4000e99c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4000e9a0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000e9a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e9a8: 81 c7 e0 08 ret <== NOT EXECUTED
4000e9ac: 81 e8 00 00 restore <== NOT EXECUTED
4000e7ac <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000e7ac: 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,
4000e7b0: 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(
4000e7b4: 92 10 20 00 clr %o1
4000e7b8: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
4000e7bc: 7f ff eb 0f call 400093f8 <rtems_semaphore_obtain>
4000e7c0: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
4000e7c4: 80 a2 20 00 cmp %o0, 0
4000e7c8: 12 80 00 04 bne 4000e7d8 <msdos_lock+0x2c> <== NEVER TAKEN
4000e7cc: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
4000e7d0: 81 c7 e0 08 ret
4000e7d4: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
4000e7d8: 7f ff ec e9 call 40009b7c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000e7dc: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
400185dc <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)
{
400185dc: 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);
400185e0: 92 10 20 20 mov 0x20, %o1
400185e4: 90 10 00 1a mov %i2, %o0
400185e8: 40 00 12 4c call 4001cf18 <memset>
400185ec: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
400185f0: f8 0e 00 00 ldub [ %i0 ], %i4
400185f4: 85 2f 20 18 sll %i4, 0x18, %g2
400185f8: 83 38 a0 18 sra %g2, 0x18, %g1
400185fc: 80 a0 60 2e cmp %g1, 0x2e
40018600: 02 80 00 17 be 4001865c <msdos_long_to_short+0x80>
40018604: a0 10 00 18 mov %i0, %l0
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
40018608: 80 a6 60 00 cmp %i1, 0
4001860c: 04 80 00 70 ble 400187cc <msdos_long_to_short+0x1f0> <== NEVER TAKEN
40018610: 83 38 a0 18 sra %g2, 0x18, %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40018614: 80 a0 60 2e cmp %g1, 0x2e
40018618: 12 80 00 1f bne 40018694 <msdos_long_to_short+0xb8> <== ALWAYS TAKEN
4001861c: 80 a0 60 20 cmp %g1, 0x20
40018620: 10 80 00 05 b 40018634 <msdos_long_to_short+0x58> <== NOT EXECUTED
40018624: 82 10 20 00 clr %g1 <== NOT EXECUTED
40018628: 80 a0 e0 2e cmp %g3, 0x2e
4001862c: 12 80 00 08 bne 4001864c <msdos_long_to_short+0x70> <== ALWAYS TAKEN
40018630: 80 a0 e0 20 cmp %g3, 0x20
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
40018634: 82 00 60 01 inc %g1
40018638: 80 a0 40 19 cmp %g1, %i1
4001863c: 32 bf ff fb bne,a 40018628 <msdos_long_to_short+0x4c> <== ALWAYS TAKEN
40018640: 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;
40018644: 81 c7 e0 08 ret <== NOT EXECUTED
40018648: 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] != '.'))
4001864c: 02 bf ff fb be 40018638 <msdos_long_to_short+0x5c> <== NEVER TAKEN
40018650: 82 00 60 01 inc %g1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
40018654: 10 80 00 13 b 400186a0 <msdos_long_to_short+0xc4>
40018658: 80 a0 a0 00 cmp %g2, 0
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
4001865c: 80 a6 60 01 cmp %i1, 1
40018660: 22 80 00 0b be,a 4001868c <msdos_long_to_short+0xb0>
40018664: 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))
40018668: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
4001866c: 80 a0 60 2e cmp %g1, 0x2e
40018670: 12 bf ff e7 bne 4001860c <msdos_long_to_short+0x30> <== NEVER TAKEN
40018674: 80 a6 60 00 cmp %i1, 0
40018678: 80 a6 60 02 cmp %i1, 2
4001867c: 12 bf ff e4 bne 4001860c <msdos_long_to_short+0x30> <== NEVER TAKEN
40018680: 80 a6 60 00 cmp %i1, 0
{
sfn[0] = sfn[1] = '.';
40018684: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
40018688: 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;
4001868c: 81 c7 e0 08 ret
40018690: 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] != '.'))
40018694: 02 bf ff e8 be 40018634 <msdos_long_to_short+0x58>
40018698: 82 10 20 00 clr %g1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
4001869c: 80 a0 a0 00 cmp %g2, 0
400186a0: 02 80 00 44 be 400187b0 <msdos_long_to_short+0x1d4> <== NEVER TAKEN
400186a4: 03 10 00 b6 sethi %hi(0x4002d800), %g1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
400186a8: e8 00 63 44 ld [ %g1 + 0x344 ], %l4 ! 4002db44 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400186ac: 31 10 00 b4 sethi %hi(0x4002d000), %i0
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400186b0: 2b 10 00 b4 sethi %hi(0x4002d000), %l5
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
400186b4: a4 10 20 00 clr %l2
400186b8: a6 10 20 00 clr %l3
400186bc: ba 10 20 00 clr %i5
400186c0: a2 10 3f ff mov -1, %l1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400186c4: b0 16 20 e0 or %i0, 0xe0, %i0
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400186c8: aa 15 60 e8 or %l5, 0xe8, %l5
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400186cc: b7 38 a0 18 sra %g2, 0x18, %i3
400186d0: 90 10 00 18 mov %i0, %o0
400186d4: 40 00 15 55 call 4001dc28 <strchr>
400186d8: 92 10 00 1b mov %i3, %o1
400186dc: 80 a2 20 00 cmp %o0, 0
400186e0: 02 80 00 09 be 40018704 <msdos_long_to_short+0x128>
400186e4: 82 1e e0 2e xor %i3, 0x2e, %g1
return MSDOS_NAME_LONG;
400186e8: 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);
400186ec: 90 10 00 10 mov %l0, %o0
400186f0: 92 10 00 19 mov %i1, %o1
400186f4: 40 00 0b c1 call 4001b5f8 <msdos_filename_unix2dos>
400186f8: 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;
400186fc: 81 c7 e0 08 ret
40018700: 81 e8 00 00 restore
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
40018704: 80 a0 00 01 cmp %g0, %g1
40018708: 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) ||
4001870c: 80 a5 a0 00 cmp %l6, 0
40018710: 12 80 00 3c bne 40018800 <msdos_long_to_short+0x224>
40018714: 82 0f 20 ff and %i4, 0xff, %g1
40018718: 82 05 00 01 add %l4, %g1, %g1
4001871c: c2 08 60 01 ldub [ %g1 + 1 ], %g1
40018720: 80 88 60 07 btst 7, %g1
40018724: 12 80 00 07 bne 40018740 <msdos_long_to_short+0x164>
40018728: 90 10 00 15 mov %l5, %o0
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
4001872c: 40 00 15 3f call 4001dc28 <strchr>
40018730: 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) ||
40018734: 80 a2 20 00 cmp %o0, 0
40018738: 02 bf ff c3 be 40018644 <msdos_long_to_short+0x68> <== NEVER TAKEN
4001873c: 01 00 00 00 nop
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
40018740: 80 a4 7f ff cmp %l1, -1
40018744: 02 80 00 27 be 400187e0 <msdos_long_to_short+0x204>
40018748: 82 27 40 11 sub %i5, %l1, %g1
{
if (is_dot || ((count - dot_at) > 3))
4001874c: 80 a0 60 03 cmp %g1, 3
40018750: 34 bf ff e7 bg,a 400186ec <msdos_long_to_short+0x110> <== NEVER TAKEN
40018754: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
40018758: 82 07 3f bf add %i4, -65, %g1
4001875c: 82 08 60 ff and %g1, 0xff, %g1
40018760: 80 a0 60 19 cmp %g1, 0x19
40018764: 28 80 00 07 bleu,a 40018780 <msdos_long_to_short+0x1a4>
40018768: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
4001876c: b8 07 3f 9f add %i4, -97, %i4
40018770: b8 0f 20 ff and %i4, 0xff, %i4
40018774: 80 a7 20 19 cmp %i4, 0x19
40018778: 28 80 00 02 bleu,a 40018780 <msdos_long_to_short+0x1a4>
4001877c: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
40018780: ba 07 60 01 inc %i5
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
40018784: f8 0c 00 1d ldub [ %l0 + %i5 ], %i4
40018788: 85 2f 20 18 sll %i4, 0x18, %g2
4001878c: 80 a0 a0 00 cmp %g2, 0
40018790: 02 80 00 04 be 400187a0 <msdos_long_to_short+0x1c4>
40018794: 80 a6 40 1d cmp %i1, %i5
40018798: 34 bf ff ce bg,a 400186d0 <msdos_long_to_short+0xf4>
4001879c: b7 38 a0 18 sra %g2, 0x18, %i3
400187a0: a4 0c c0 12 and %l3, %l2, %l2
count++;
name++;
}
if (lowercase && uppercase)
400187a4: 80 8c a0 ff btst 0xff, %l2
400187a8: 12 bf ff d1 bne 400186ec <msdos_long_to_short+0x110> <== NEVER TAKEN
400187ac: b0 10 20 02 mov 2, %i0
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
400187b0: 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);
400187b4: 90 10 00 10 mov %l0, %o0
400187b8: 92 10 00 19 mov %i1, %o1
400187bc: 40 00 0b 8f call 4001b5f8 <msdos_filename_unix2dos>
400187c0: 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;
400187c4: 81 c7 e0 08 ret
400187c8: 81 e8 00 00 restore
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
400187cc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400187d0: 12 bf ff f8 bne 400187b0 <msdos_long_to_short+0x1d4> <== NOT EXECUTED
400187d4: 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;
}
400187d8: 81 c7 e0 08 ret <== NOT EXECUTED
400187dc: 81 e8 00 00 restore <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
400187e0: 80 a5 a0 00 cmp %l6, 0
400187e4: 12 bf ff de bne 4001875c <msdos_long_to_short+0x180> <== NEVER TAKEN
400187e8: 82 07 3f bf add %i4, -65, %g1
400187ec: 80 a7 60 08 cmp %i5, 8
400187f0: 12 bf ff dc bne 40018760 <msdos_long_to_short+0x184>
400187f4: 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;
400187f8: 10 bf ff bd b 400186ec <msdos_long_to_short+0x110>
400187fc: b0 10 20 02 mov 2, %i0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
40018800: 80 a4 7f ff cmp %l1, -1
40018804: 32 bf ff ba bne,a 400186ec <msdos_long_to_short+0x110>
40018808: b0 10 20 02 mov 2, %i0
4001880c: 10 bf ff dd b 40018780 <msdos_long_to_short+0x1a4>
40018810: a2 10 00 1d mov %i5, %l1
4000e9b0 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000e9b0: 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))
4000e9b4: 03 00 00 3c sethi %hi(0xf000), %g1
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000e9b8: 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))
4000e9bc: 82 0e c0 01 and %i3, %g1, %g1
4000e9c0: 05 00 00 10 sethi %hi(0x4000), %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000e9c4: 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))
4000e9c8: 80 a0 40 02 cmp %g1, %g2
4000e9cc: 02 80 00 09 be 4000e9f0 <msdos_mknod+0x40>
4000e9d0: b6 10 00 1a mov %i2, %i3
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
4000e9d4: 05 00 00 20 sethi %hi(0x8000), %g2
4000e9d8: 80 a0 40 02 cmp %g1, %g2
4000e9dc: 12 80 00 09 bne 4000ea00 <msdos_mknod+0x50> <== NEVER TAKEN
4000e9e0: 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);
4000e9e4: b4 10 00 03 mov %g3, %i2
4000e9e8: 40 00 25 9c call 40018058 <msdos_creat_node>
4000e9ec: 9b e8 20 00 restore %g0, 0, %o5
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
4000e9f0: 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);
4000e9f4: b4 10 00 03 mov %g3, %i2
4000e9f8: 40 00 25 98 call 40018058 <msdos_creat_node>
4000e9fc: 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);
4000ea00: 40 00 36 64 call 4001c390 <__errno> <== NOT EXECUTED
4000ea04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000ea08: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000ea0c: 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;
}
4000ea10: 81 c7 e0 08 ret <== NOT EXECUTED
4000ea14: 81 e8 00 00 restore <== NOT EXECUTED
4000ea24 <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
)
{
4000ea24: 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;
4000ea28: 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,
4000ea2c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000ea30: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000ea34: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000ea38: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000ea3c: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
4000ea40: 40 00 25 86 call 40018058 <msdos_creat_node> <== NOT EXECUTED
4000ea44: 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)
4000ea48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000ea4c: 02 80 00 04 be 4000ea5c <msdos_rename+0x38> <== NOT EXECUTED
4000ea50: 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;
}
4000ea54: 81 c7 e0 08 ret <== NOT EXECUTED
4000ea58: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4000ea5c: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
4000ea60: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
4000ea64: 40 00 28 15 call 40018ab8 <msdos_set_first_char4file_name><== NOT EXECUTED
4000ea68: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
4000ea6c <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
4000ea6c: 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;
4000ea70: 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;
4000ea74: 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)
4000ea78: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000ea7c: 80 a0 60 00 cmp %g1, 0
4000ea80: 12 80 00 16 bne 4000ead8 <msdos_rmnod+0x6c>
4000ea84: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
4000ea88: 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);
4000ea8c: 92 10 00 1d mov %i5, %o1
4000ea90: 40 00 28 76 call 40018c68 <msdos_dir_is_empty>
4000ea94: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
4000ea98: b0 92 20 00 orcc %o0, 0, %i0
4000ea9c: 12 80 00 0d bne 4000ead0 <msdos_rmnod+0x64> <== NEVER TAKEN
4000eaa0: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
4000eaa4: 80 a0 60 00 cmp %g1, 0
4000eaa8: 02 80 00 16 be 4000eb00 <msdos_rmnod+0x94>
4000eaac: 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)
4000eab0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000eab4: 80 a0 60 01 cmp %g1, 1
4000eab8: 28 80 00 08 bleu,a 4000ead8 <msdos_rmnod+0x6c> <== ALWAYS TAKEN
4000eabc: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
4000eac0: 40 00 36 34 call 4001c390 <__errno> <== NOT EXECUTED
4000eac4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000eac8: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
4000eacc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000ead0: 81 c7 e0 08 ret <== NOT EXECUTED
4000ead4: 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,
4000ead8: 92 07 60 20 add %i5, 0x20, %o1
4000eadc: 40 00 27 f7 call 40018ab8 <msdos_set_first_char4file_name>
4000eae0: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
4000eae4: b0 92 20 00 orcc %o0, 0, %i0
4000eae8: 12 bf ff fa bne 4000ead0 <msdos_rmnod+0x64> <== NEVER TAKEN
4000eaec: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
4000eaf0: 40 00 11 79 call 400130d4 <fat_file_mark_removed>
4000eaf4: 92 10 00 1d mov %i5, %o1
return rc;
}
4000eaf8: 81 c7 e0 08 ret
4000eafc: 81 e8 00 00 restore
return rc;
}
if (!is_empty)
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
4000eb00: 40 00 36 24 call 4001c390 <__errno>
4000eb04: b0 10 3f ff mov -1, %i0
4000eb08: 82 10 20 5a mov 0x5a, %g1
4000eb0c: c2 22 00 00 st %g1, [ %o0 ]
4000eb10: 81 c7 e0 08 ret
4000eb14: 81 e8 00 00 restore
40018814 <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
)
{
40018814: 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);
40018818: 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;
4001881c: 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);
40018820: 92 07 bf fe add %fp, -2, %o1
40018824: 40 00 0a c9 call 4001b348 <msdos_date_unix2dos>
40018828: 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);
4001882c: 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)) )
40018830: 80 a0 60 00 cmp %g1, 0
40018834: 32 80 00 07 bne,a 40018850 <msdos_set_dir_wrt_time_and_date+0x3c>
40018838: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
4001883c: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
40018840: 80 88 a0 03 btst 3, %g2
40018844: 32 80 00 07 bne,a 40018860 <msdos_set_dir_wrt_time_and_date+0x4c><== ALWAYS TAKEN
40018848: f6 07 60 20 ld [ %i5 + 0x20 ], %i3
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4001884c: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
40018850: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
40018854: b6 00 7f fe add %g1, -2, %i3
40018858: b7 2e c0 03 sll %i3, %g3, %i3
4001885c: b6 06 c0 02 add %i3, %g2, %i3
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40018860: 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);
40018864: f8 17 40 00 lduh [ %i5 ], %i4
time_val = CT_LE_W(time_val);
40018868: 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);
4001886c: 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);
40018870: 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);
40018874: 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);
40018878: b8 07 3f ff add %i4, -1, %i4
4001887c: b8 0f 00 02 and %i4, %g2, %i4
time_val = CT_LE_W(time_val);
40018880: 85 30 60 08 srl %g1, 8, %g2
40018884: 83 30 60 18 srl %g1, 0x18, %g1
40018888: 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);
4001888c: 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,
40018890: 94 07 20 16 add %i4, 0x16, %o2
40018894: 92 10 00 1b mov %i3, %o1
40018898: 96 10 20 02 mov 2, %o3
4001889c: 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);
400188a0: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
400188a4: 7f ff eb 2d call 40013558 <fat_sector_write>
400188a8: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
400188ac: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188b0: 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);
400188b4: 83 28 60 10 sll %g1, 0x10, %g1
400188b8: 85 30 60 08 srl %g1, 8, %g2
400188bc: 83 30 60 18 srl %g1, 0x18, %g1
400188c0: 82 10 80 01 or %g2, %g1, %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188c4: 96 10 20 02 mov 2, %o3
400188c8: 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);
400188cc: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188d0: 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,
400188d4: 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,
400188d8: 7f ff eb 20 call 40013558 <fat_sector_write>
400188dc: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
400188e0: 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,
400188e4: b4 10 00 08 mov %o0, %i2
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
400188e8: 94 07 20 12 add %i4, 0x12, %o2
400188ec: 90 10 00 1d mov %i5, %o0
400188f0: 96 10 20 02 mov 2, %o3
400188f4: 7f ff eb 19 call 40013558 <fat_sector_write>
400188f8: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
400188fc: 80 a6 a0 00 cmp %i2, 0
40018900: 06 80 00 08 bl 40018920 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40018904: 80 a6 60 00 cmp %i1, 0
40018908: 06 80 00 06 bl 40018920 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
4001890c: 80 a2 20 00 cmp %o0, 0
40018910: 06 80 00 04 bl 40018920 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40018914: 01 00 00 00 nop
return -1;
return RC_OK;
}
40018918: 81 c7 e0 08 ret
4001891c: 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;
40018920: 81 c7 e0 08 ret <== NOT EXECUTED
40018924: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40018a14 <msdos_set_file_size>:
int
msdos_set_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
40018a14: 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);
40018a18: 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)) )
40018a1c: 80 a0 60 00 cmp %g1, 0
40018a20: 12 80 00 06 bne 40018a38 <msdos_set_file_size+0x24>
40018a24: d0 06 20 08 ld [ %i0 + 8 ], %o0
40018a28: c4 0a 20 0e ldub [ %o0 + 0xe ], %g2
40018a2c: 80 88 a0 03 btst 3, %g2
40018a30: 32 80 00 07 bne,a 40018a4c <msdos_set_file_size+0x38> <== ALWAYS TAKEN
40018a34: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40018a38: c6 0a 20 05 ldub [ %o0 + 5 ], %g3
40018a3c: c4 02 20 34 ld [ %o0 + 0x34 ], %g2
40018a40: 92 00 7f fe add %g1, -2, %o1
40018a44: 93 2a 40 03 sll %o1, %g3, %o1
40018a48: 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));
40018a4c: c6 12 00 00 lduh [ %o0 ], %g3
le_new_length = CT_LE_L((fat_fd->fat_file_size));
40018a50: 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);
40018a54: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40018a58: c8 0a 20 02 ldub [ %o0 + 2 ], %g4
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40018a5c: 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);
40018a60: 89 30 80 04 srl %g2, %g4, %g4
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40018a64: 94 08 c0 02 and %g3, %g2, %o2
40018a68: b9 28 60 18 sll %g1, 0x18, %i4
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
40018a6c: 87 30 60 18 srl %g1, 0x18, %g3
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
40018a70: bb 30 60 08 srl %g1, 8, %i5
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40018a74: 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;
40018a78: ba 0f 60 ff and %i5, 0xff, %i5
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40018a7c: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40018a80: bb 2f 60 10 sll %i5, 0x10, %i5
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40018a84: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40018a88: 86 10 c0 1d or %g3, %i5, %g3
40018a8c: 83 28 60 08 sll %g1, 8, %g1
40018a90: 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,
40018a94: 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));
40018a98: c6 27 bf fc st %g3, [ %fp + -4 ]
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40018a9c: 94 02 a0 1c add %o2, 0x1c, %o2
40018aa0: 96 10 20 04 mov 4, %o3
40018aa4: 7f ff ea ad call 40013558 <fat_sector_write>
40018aa8: 98 07 bf fc add %fp, -4, %o4
(char *)(&le_new_length));
if ( ret < 0 )
return -1;
return RC_OK;
}
40018aac: b1 3a 20 1f sra %o0, 0x1f, %i0
40018ab0: 81 c7 e0 08 ret
40018ab4: 81 e8 00 00 restore
40018ab8 <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
)
{
40018ab8: 9d e3 bf 90 save %sp, -112, %sp
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40018abc: 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;
40018ac0: 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;
40018ac4: c8 06 60 08 ld [ %i1 + 8 ], %g4
40018ac8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
fat_pos_t end = dir_pos->sname;
40018acc: c2 06 60 04 ld [ %i1 + 4 ], %g1
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40018ad0: 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
)
{
40018ad4: 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;
40018ad8: c8 27 bf f0 st %g4, [ %fp + -16 ]
40018adc: c6 27 bf f4 st %g3, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
40018ae0: f8 27 bf f8 st %i4, [ %fp + -8 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40018ae4: 80 a7 00 02 cmp %i4, %g2
40018ae8: 02 80 00 56 be 40018c40 <msdos_set_first_char4file_name+0x188><== ALWAYS TAKEN
40018aec: 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)
40018af0: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
40018af4: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
40018af8: 02 80 00 59 be 40018c5c <msdos_set_first_char4file_name+0x1a4><== NOT EXECUTED
40018afc: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
40018b00: c2 07 bf f4 ld [ %fp + -12 ], %g1
40018b04: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
40018b08: d4 17 40 00 lduh [ %i5 ], %o2
40018b0c: 10 80 00 1d b 40018b80 <msdos_set_first_char4file_name+0xc8>
40018b10: 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)) )
40018b14: 80 88 e0 03 btst 3, %g3
40018b18: 22 80 00 1e be,a 40018b90 <msdos_set_first_char4file_name+0xd8><== NEVER TAKEN
40018b1c: c8 0f 60 05 ldub [ %i5 + 5 ], %g4 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40018b20: 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));
40018b24: 85 30 40 02 srl %g1, %g2, %g2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40018b28: 95 2a a0 10 sll %o2, 0x10, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018b2c: 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));
40018b30: 95 32 a0 10 srl %o2, 0x10, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018b34: 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));
40018b38: 94 02 bf ff add %o2, -1, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018b3c: 96 10 20 01 mov 1, %o3
40018b40: 94 08 40 0a and %g1, %o2, %o2
40018b44: 7f ff ea 85 call 40013558 <fat_sector_write>
40018b48: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
40018b4c: 80 a2 20 00 cmp %o0, 0
40018b50: 06 80 00 22 bl 40018bd8 <msdos_set_first_char4file_name+0x120><== NEVER TAKEN
40018b54: 90 10 3f ff mov -1, %o0
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
40018b58: d2 07 bf f0 ld [ %fp + -16 ], %o1
40018b5c: 80 a7 00 09 cmp %i4, %o1
40018b60: 02 80 00 20 be 40018be0 <msdos_set_first_char4file_name+0x128><== ALWAYS TAKEN
40018b64: c2 07 bf f4 ld [ %fp + -12 ], %g1
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40018b68: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
40018b6c: 80 a6 c0 01 cmp %i3, %g1
40018b70: 08 80 00 23 bleu 40018bfc <msdos_set_first_char4file_name+0x144><== NEVER TAKEN
40018b74: c2 27 bf f4 st %g1, [ %fp + -12 ]
40018b78: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
40018b7c: 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)) )
40018b80: 80 a2 60 00 cmp %o1, 0
40018b84: 22 bf ff e4 be,a 40018b14 <msdos_set_first_char4file_name+0x5c><== ALWAYS TAKEN
40018b88: c6 0f 60 0e ldub [ %i5 + 0xe ], %g3
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40018b8c: c8 0f 60 05 ldub [ %i5 + 5 ], %g4 <== NOT EXECUTED
40018b90: 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));
40018b94: 85 30 40 02 srl %g1, %g2, %g2 <== NOT EXECUTED
40018b98: 92 02 7f fe add %o1, -2, %o1 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40018b9c: 95 2a a0 10 sll %o2, 0x10, %o2 <== NOT EXECUTED
40018ba0: 93 2a 40 04 sll %o1, %g4, %o1 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018ba4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40018ba8: 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));
40018bac: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018bb0: 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));
40018bb4: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018bb8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
40018bbc: 94 08 40 0a and %g1, %o2, %o2 <== NOT EXECUTED
40018bc0: 7f ff ea 66 call 40013558 <fat_sector_write> <== NOT EXECUTED
40018bc4: 98 07 a0 4c add %fp, 0x4c, %o4 <== NOT EXECUTED
1, &fchar);
if (ret < 0)
40018bc8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40018bcc: 16 bf ff e4 bge 40018b5c <msdos_set_first_char4file_name+0xa4><== NOT EXECUTED
40018bd0: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
return -1;
40018bd4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
40018bd8: 81 c7 e0 08 ret <== NOT EXECUTED
40018bdc: 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))
40018be0: c4 07 bf fc ld [ %fp + -4 ], %g2
40018be4: 80 a0 40 02 cmp %g1, %g2
40018be8: 32 bf ff e1 bne,a 40018b6c <msdos_set_first_char4file_name+0xb4>
40018bec: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
40018bf0: 90 10 20 00 clr %o0
}
40018bf4: 81 c7 e0 08 ret
40018bf8: 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) &&
40018bfc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
40018c00: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40018c04: 12 80 00 06 bne 40018c1c <msdos_set_first_char4file_name+0x164><== NOT EXECUTED
40018c08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
40018c0c: 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) &&
40018c10: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40018c14: 32 bf ff f8 bne,a 40018bf4 <msdos_set_first_char4file_name+0x13c><== NOT EXECUTED
40018c18: 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);
40018c1c: 40 00 05 48 call 4001a13c <fat_get_fat_cluster> <== NOT EXECUTED
40018c20: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
40018c24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40018c28: 12 bf ff ec bne 40018bd8 <msdos_set_first_char4file_name+0x120><== NOT EXECUTED
40018c2c: 82 10 20 00 clr %g1 <== NOT EXECUTED
return rc;
start.ofs = 0;
40018c30: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
40018c34: d4 17 40 00 lduh [ %i5 ], %o2 <== NOT EXECUTED
40018c38: 10 bf ff b5 b 40018b0c <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
40018c3c: 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)))
40018c40: 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) &&
40018c44: 80 88 a0 03 btst 3, %g2
40018c48: 02 bf ff ab be 40018af4 <msdos_set_first_char4file_name+0x3c><== NEVER TAKEN
40018c4c: 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)
40018c50: 80 a0 bf ff cmp %g2, -1
40018c54: 12 bf ff ab bne 40018b00 <msdos_set_first_char4file_name+0x48>
40018c58: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
start = dir_pos->sname;
40018c5c: f8 27 bf f0 st %i4, [ %fp + -16 ]
40018c60: 10 bf ff a8 b 40018b00 <msdos_set_first_char4file_name+0x48>
40018c64: c2 27 bf f4 st %g1, [ %fp + -12 ]
40018928 <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
)
{
40018928: 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);
4001892c: 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;
40018930: 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;
40018934: 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)) )
40018938: 80 a0 60 00 cmp %g1, 0
4001893c: 12 80 00 06 bne 40018954 <msdos_set_first_cluster_num+0x2c>
40018940: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
40018944: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
40018948: 80 88 a0 03 btst 3, %g2
4001894c: 32 80 00 07 bne,a 40018968 <msdos_set_first_cluster_num+0x40><== ALWAYS TAKEN
40018950: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40018954: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
40018958: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
4001895c: b4 00 7f fe add %g1, -2, %i2
40018960: b5 2e 80 03 sll %i2, %g3, %i2
40018964: 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);
40018968: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4001896c: 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);
40018970: 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);
40018974: 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);
40018978: 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);
4001897c: 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);
40018980: b6 0e c0 01 and %i3, %g1, %i3
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40018984: 85 2f 20 10 sll %i4, 0x10, %g2
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40018988: 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));
4001898c: 85 30 a0 18 srl %g2, 0x18, %g2
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40018990: b2 16 63 ff or %i1, 0x3ff, %i1
40018994: 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));
40018998: 83 28 60 08 sll %g1, 8, %g1
4001899c: 82 10 40 02 or %g1, %g2, %g1
ret1 = fat_sector_write(&fs_info->fat, sec,
400189a0: 94 06 e0 1a add %i3, 0x1a, %o2
400189a4: 92 10 00 1a mov %i2, %o1
400189a8: 96 10 20 02 mov 2, %o3
400189ac: 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));
400189b0: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec,
400189b4: 7f ff ea e9 call 40013558 <fat_sector_write>
400189b8: 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));
400189bc: 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,
400189c0: a0 10 00 08 mov %o0, %l0
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
400189c4: 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,
400189c8: 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));
400189cc: b9 37 20 08 srl %i4, 8, %i4
400189d0: b3 2e 60 08 sll %i1, 8, %i1
ret2 = fat_sector_write(&fs_info->fat, sec,
400189d4: 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));
400189d8: b8 16 40 1c or %i1, %i4, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
400189dc: 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));
400189e0: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec,
400189e4: 96 10 20 02 mov 2, %o3
400189e8: 7f ff ea dc call 40013558 <fat_sector_write>
400189ec: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
400189f0: 80 a2 20 00 cmp %o0, 0
400189f4: 06 80 00 06 bl 40018a0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
400189f8: 80 a4 20 00 cmp %l0, 0
400189fc: 06 80 00 04 bl 40018a0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
40018a00: b0 10 20 00 clr %i0
return -1;
return RC_OK;
}
40018a04: 81 c7 e0 08 ret
40018a08: 81 e8 00 00 restore
40018a0c: 81 c7 e0 08 ret <== NOT EXECUTED
40018a10: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4000d5c4 <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 )
{
4000d5c4: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
4000d5c8: 80 a6 20 00 cmp %i0, 0
4000d5cc: 22 80 00 07 be,a 4000d5e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000d5d0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000d5d4: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000d5d8: 80 a0 60 00 cmp %g1, 0
4000d5dc: 22 80 00 03 be,a 4000d5e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000d5e0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;
4000d5e4: 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 )
{
4000d5e8: b8 10 20 08 mov 8, %i4
4000d5ec: 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 ) {
4000d5f0: 80 a0 40 1d cmp %g1, %i5
4000d5f4: 2a 80 00 0b bcs,a 4000d620 <msdos_set_sectors_per_cluster_from_request+0x5c>
4000d5f8: 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 ) {
4000d5fc: 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;
4000d600: fa 26 60 0c st %i5, [ %i1 + 0xc ]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
4000d604: 7f ff d4 1c call 40002674 <.udiv>
4000d608: 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
4000d60c: 80 a2 00 1d cmp %o0, %i5
4000d610: 0a 80 00 04 bcs 4000d620 <msdos_set_sectors_per_cluster_from_request+0x5c><== NEVER TAKEN
4000d614: 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;
4000d618: 81 c7 e0 08 ret
4000d61c: 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 ) {
4000d620: 02 80 00 04 be 4000d630 <msdos_set_sectors_per_cluster_from_request+0x6c><== NEVER TAKEN
4000d624: bb 37 60 01 srl %i5, 1, %i5
4000d628: 10 bf ff f2 b 4000d5f0 <msdos_set_sectors_per_cluster_from_request+0x2c>
4000d62c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
}
}
}
if (ret_val != 0) {
errno = EINVAL;
4000d630: 40 00 3b 58 call 4001c390 <__errno> <== NOT EXECUTED
4000d634: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000d638: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000d63c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return ret_val;
}
4000d640: 81 c7 e0 08 ret <== NOT EXECUTED
4000d644: 81 e8 00 00 restore <== NOT EXECUTED
40019fdc <msdos_sync>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
40019fdc: 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;
40019fe0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
40019fe4: 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;
40019fe8: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
40019fec: 94 10 20 00 clr %o2
40019ff0: 7f ff bd 02 call 400093f8 <rtems_semaphore_obtain>
40019ff4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40019ff8: 80 a2 20 00 cmp %o0, 0
40019ffc: 12 80 00 09 bne 4001a020 <msdos_sync+0x44> <== NEVER TAKEN
4001a000: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_sync(&fs_info->fat);
4001a004: 7f ff e8 48 call 40014124 <fat_sync>
4001a008: 90 10 00 1d mov %i5, %o0
4001a00c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
4001a010: 7f ff bd 49 call 40009534 <rtems_semaphore_release>
4001a014: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001a018: 81 c7 e0 08 ret
4001a01c: 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);
4001a020: 40 00 08 dc call 4001c390 <__errno> <== NOT EXECUTED
4001a024: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a028: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a02c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a030: 81 c7 e0 08 ret <== NOT EXECUTED
4001a034: 81 e8 00 00 restore <== NOT EXECUTED
4000e77c <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000e77c: 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);
4000e780: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000e784: 7f ff eb 6c call 40009534 <rtems_semaphore_release>
4000e788: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
if (sc != RTEMS_SUCCESSFUL) {
4000e78c: 80 a2 20 00 cmp %o0, 0
4000e790: 12 80 00 04 bne 4000e7a0 <msdos_unlock+0x24> <== NEVER TAKEN
4000e794: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
4000e798: 81 c7 e0 08 ret
4000e79c: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
4000e7a0: 7f ff ec f7 call 40009b7c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000e7a4: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40003b94 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
40003b94: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
40003b98: 03 10 00 79 sethi %hi(0x4001e400), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
40003b9c: 80 a6 00 19 cmp %i0, %i1
40003ba0: 02 80 00 03 be 40003bac <newlib_delete_hook+0x18>
40003ba4: fa 00 61 68 ld [ %g1 + 0x168 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
40003ba8: fa 06 61 48 ld [ %i1 + 0x148 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
40003bac: 80 a7 60 00 cmp %i5, 0
40003bb0: 02 80 00 0b be 40003bdc <newlib_delete_hook+0x48> <== NEVER TAKEN
40003bb4: 03 10 00 76 sethi %hi(0x4001d800), %g1
40003bb8: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 4001d8b0 <_global_impure_ptr>
40003bbc: 80 a7 40 01 cmp %i5, %g1
40003bc0: 02 80 00 07 be 40003bdc <newlib_delete_hook+0x48>
40003bc4: 13 10 00 0e sethi %hi(0x40003800), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
40003bc8: 90 10 00 1d mov %i5, %o0
40003bcc: 40 00 30 ea call 4000ff74 <_fwalk>
40003bd0: 92 12 61 84 or %o1, 0x184, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
40003bd4: 40 00 1d 16 call 4000b02c <_Workspace_Free>
40003bd8: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
40003bdc: 80 a6 00 19 cmp %i0, %i1
40003be0: 12 80 00 04 bne 40003bf0 <newlib_delete_hook+0x5c>
40003be4: c0 26 61 48 clr [ %i1 + 0x148 ]
_REENT = 0;
40003be8: 03 10 00 79 sethi %hi(0x4001e400), %g1
40003bec: c0 20 61 68 clr [ %g1 + 0x168 ] ! 4001e568 <_impure_ptr>
40003bf0: 81 c7 e0 08 ret
40003bf4: 81 e8 00 00 restore
40003984 <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
40003984: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
40003988: 40 00 30 80 call 4000fb88 <fileno>
4000398c: 90 10 00 18 mov %i0, %o0
40003990: 80 a2 20 02 cmp %o0, 2
40003994: 28 80 00 06 bleu,a 400039ac <newlib_free_buffers+0x28> <== ALWAYS TAKEN
40003998: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
4000399c: 40 00 2f bb call 4000f888 <fclose> <== NOT EXECUTED
400039a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
400039a4: 81 c7 e0 08 ret
400039a8: 91 e8 20 00 restore %g0, 0, %o0
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
400039ac: 80 88 60 80 btst 0x80, %g1
400039b0: 02 bf ff fd be 400039a4 <newlib_free_buffers+0x20> <== ALWAYS TAKEN
400039b4: 01 00 00 00 nop
free( fp->_bf._base );
400039b8: 7f ff fd 9c call 40003028 <free> <== NOT EXECUTED
400039bc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
400039c0: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
400039c4: 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;
400039c8: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
400039cc: 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;
400039d0: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
400039d4: 81 c7 e0 08 ret <== NOT EXECUTED
400039d8: 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 9e sethi %hi(0x40027800), %o0 <== NOT EXECUTED
40002034: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40002038: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
4000203c: 40 00 6c 49 call 4001d160 <printf> <== NOT EXECUTED
40002040: 31 10 00 9e sethi %hi(0x40027800), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
40002044: 40 00 6c 88 call 4001d264 <puts> <== NOT EXECUTED
40002048: 91 ee 21 e0 restore %i0, 0x1e0, %o0 <== NOT EXECUTED
40006828 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
40006828: 81 c3 e0 08 retl <== NOT EXECUTED
4000682c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006838 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40006838: 81 c3 e0 08 retl <== NOT EXECUTED
40006800 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
40006800: 81 c3 e0 08 retl <== NOT EXECUTED
40006804: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006820 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
40006820: 81 c3 e0 08 retl <== NOT EXECUTED
40006824: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006850 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
40006850: 81 c3 e0 08 retl <== NOT EXECUTED
40006854: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006858 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
40006858: 81 c3 e0 08 retl <== NOT EXECUTED
4000685c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400067f8 <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
400067f8: 81 c3 e0 08 retl <== NOT EXECUTED
400067fc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
4000586c <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4000586c: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
40005870: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
40005874: 80 88 60 01 btst 1, %g1
40005878: 02 80 00 21 be 400058fc <oproc+0x90> <== NEVER TAKEN
4000587c: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
40005880: 80 a6 20 09 cmp %i0, 9
40005884: 22 80 00 3d be,a 40005978 <oproc+0x10c>
40005888: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
4000588c: 08 80 00 22 bleu 40005914 <oproc+0xa8> <== NEVER TAKEN
40005890: 80 a6 20 08 cmp %i0, 8
40005894: 80 a6 20 0a cmp %i0, 0xa
40005898: 02 80 00 2b be 40005944 <oproc+0xd8>
4000589c: 80 a6 20 0d cmp %i0, 0xd
400058a0: 02 80 00 45 be 400059b4 <oproc+0x148> <== NEVER TAKEN
400058a4: 80 88 60 10 btst 0x10, %g1
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
400058a8: 80 88 60 02 btst 2, %g1
c = toupper(c);
400058ac: 03 10 00 79 sethi %hi(0x4001e400), %g1
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
400058b0: 02 80 00 0b be 400058dc <oproc+0x70> <== ALWAYS TAKEN
400058b4: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 4001e560 <__ctype_ptr__>
c = toupper(c);
400058b8: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED
400058bc: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
400058c0: c6 0e 20 01 ldub [ %i0 + 1 ], %g3 <== NOT EXECUTED
400058c4: 86 08 e0 03 and %g3, 3, %g3 <== NOT EXECUTED
400058c8: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED
400058cc: 22 80 00 02 be,a 400058d4 <oproc+0x68> <== NOT EXECUTED
400058d0: 84 00 bf e0 add %g2, -32, %g2 <== NOT EXECUTED
400058d4: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
400058d8: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED
if (!iscntrl(c))
400058dc: b0 00 40 18 add %g1, %i0, %i0
400058e0: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
400058e4: 80 88 60 20 btst 0x20, %g1
400058e8: 12 80 00 06 bne 40005900 <oproc+0x94> <== NEVER TAKEN
400058ec: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
400058f0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
400058f4: 82 00 60 01 inc %g1
400058f8: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
400058fc: 90 07 a0 44 add %fp, 0x44, %o0
40005900: 92 10 20 01 mov 1, %o1
40005904: 7f ff ff 8a call 4000572c <rtems_termios_puts>
40005908: 94 10 00 19 mov %i1, %o2
4000590c: 81 c7 e0 08 ret
40005910: 81 e8 00 00 restore
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
40005914: 12 bf ff e6 bne 400058ac <oproc+0x40> <== NOT EXECUTED
40005918: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
4000591c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
40005920: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005924: 04 bf ff f6 ble 400058fc <oproc+0x90> <== NOT EXECUTED
40005928: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
4000592c: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
tty->column += i;
break;
case '\b':
if (tty->column > 0)
tty->column--;
40005930: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
40005934: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40005938: 7f ff ff 7d call 4000572c <rtems_termios_puts> <== NOT EXECUTED
4000593c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005940: 30 80 00 1b b,a 400059ac <oproc+0x140> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
40005944: 80 88 60 20 btst 0x20, %g1
40005948: 32 80 00 02 bne,a 40005950 <oproc+0xe4> <== NEVER TAKEN
4000594c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
40005950: 80 88 60 04 btst 4, %g1
40005954: 22 bf ff eb be,a 40005900 <oproc+0x94> <== NEVER TAKEN
40005958: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
rtems_termios_puts ("\r", 1, tty);
4000595c: 92 10 20 01 mov 1, %o1
40005960: 11 10 00 73 sethi %hi(0x4001cc00), %o0
40005964: 94 10 00 19 mov %i1, %o2
40005968: 7f ff ff 71 call 4000572c <rtems_termios_puts>
4000596c: 90 12 23 40 or %o0, 0x340, %o0
tty->column = 0;
40005970: 10 bf ff e3 b 400058fc <oproc+0x90>
40005974: c0 26 60 28 clr [ %i1 + 0x28 ]
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
40005978: 92 10 20 08 mov 8, %o1
4000597c: 88 08 e0 07 and %g3, 7, %g4
40005980: 92 22 40 04 sub %o1, %g4, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
40005984: 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) {
40005988: 05 00 00 06 sethi %hi(0x1800), %g2
4000598c: 82 08 40 02 and %g1, %g2, %g1
40005990: 80 a0 40 02 cmp %g1, %g2
40005994: 12 bf ff da bne 400058fc <oproc+0x90> <== NEVER TAKEN
40005998: c6 26 60 28 st %g3, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
4000599c: 11 10 00 73 sethi %hi(0x4001cc00), %o0
400059a0: 94 10 00 19 mov %i1, %o2
400059a4: 7f ff ff 62 call 4000572c <rtems_termios_puts>
400059a8: 90 12 23 48 or %o0, 0x348, %o0
return;
400059ac: 81 c7 e0 08 ret
400059b0: 81 e8 00 00 restore
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
400059b4: 02 80 00 06 be 400059cc <oproc+0x160> <== NOT EXECUTED
400059b8: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
400059bc: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
400059c0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
400059c4: 02 bf ff d2 be 4000590c <oproc+0xa0> <== NOT EXECUTED
400059c8: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
400059cc: 22 bf ff cc be,a 400058fc <oproc+0x90> <== NOT EXECUTED
400059d0: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
400059d4: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
400059d8: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400059dc: 02 bf ff c8 be 400058fc <oproc+0x90> <== NOT EXECUTED
400059e0: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
400059e4: 10 bf ff c6 b 400058fc <oproc+0x90> <== NOT EXECUTED
400059e8: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
40004464 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
40004464: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
40004468: 80 a6 20 00 cmp %i0, 0
4000446c: 02 80 00 11 be 400044b0 <partition_free+0x4c>
40004470: 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));
40004474: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
40004478: 82 08 60 7f and %g1, 0x7f, %g1
4000447c: 80 a0 60 05 cmp %g1, 5
40004480: 12 80 00 0a bne 400044a8 <partition_free+0x44> <== ALWAYS TAKEN
40004484: 01 00 00 00 nop
40004488: ba 10 20 00 clr %i5 ! 0 <PROM_START> <== NOT EXECUTED
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
4000448c: 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]);
40004490: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
40004494: 7f ff ff f4 call 40004464 <partition_free> <== NOT EXECUTED
40004498: 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;
4000449c: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
400044a0: 12 bf ff fc bne 40004490 <partition_free+0x2c> <== NOT EXECUTED
400044a4: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
400044a8: 40 00 03 b4 call 40005378 <free>
400044ac: 81 e8 00 00 restore
400044b0: 81 c7 e0 08 ret
400044b4: 81 e8 00 00 restore
400047fc <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)
{
400047fc: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
40004800: 92 10 20 00 clr %o1
40004804: 90 10 00 18 mov %i0, %o0
40004808: 40 00 06 8e call 40006240 <open>
4000480c: b8 10 00 18 mov %i0, %i4
if (fd < 0)
{
return RTEMS_INTERNAL_ERROR;
40004810: 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)
40004814: 80 a2 20 00 cmp %o0, 0
40004818: 06 80 00 09 bl 4000483c <partition_table_get+0x40> <== NEVER TAKEN
4000481c: ba 10 00 08 mov %o0, %i5
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
40004820: 40 00 03 00 call 40005420 <fstat>
40004824: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
40004828: 80 a2 20 00 cmp %o0, 0
4000482c: 02 80 00 06 be 40004844 <partition_table_get+0x48> <== ALWAYS TAKEN
40004830: 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);
40004834: 40 00 02 af call 400052f0 <close>
40004838: 90 10 00 1d mov %i5, %o0
4000483c: 81 c7 e0 08 ret
40004840: 81 e8 00 00 restore
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
40004844: 92 10 00 1c mov %i4, %o1
40004848: 40 00 47 b9 call 4001672c <strncpy>
4000484c: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
40004850: c4 1f bf d0 ldd [ %fp + -48 ], %g2
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40004854: 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;
40004858: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
4000485c: 80 a1 20 00 cmp %g4, 0
40004860: 02 80 00 03 be 4000486c <partition_table_get+0x70> <== ALWAYS TAKEN
40004864: 82 10 22 00 mov 0x200, %g1
40004868: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
4000486c: 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;
40004870: 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);
40004874: 90 10 00 1d mov %i5, %o0
40004878: 92 10 20 00 clr %o1
4000487c: 94 10 20 00 clr %o2
40004880: 96 10 20 00 clr %o3
40004884: 40 00 03 e1 call 40005808 <lseek>
40004888: b0 10 20 1b mov 0x1b, %i0
if (new_off != off) {
4000488c: 80 92 00 09 orcc %o0, %o1, %g0
40004890: 02 80 00 09 be 400048b4 <partition_table_get+0xb8> <== ALWAYS TAKEN
40004894: 90 10 00 1d mov %i5, %o0
/* get MBR sector */
rc = get_sector(fd, 0, §or);
if (rc != RTEMS_SUCCESSFUL)
{
if (sector)
40004898: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
4000489c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400048a0: 02 bf ff e5 be 40004834 <partition_table_get+0x38> <== NOT EXECUTED
400048a4: 01 00 00 00 nop <== NOT EXECUTED
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
400048a8: 40 00 02 b4 call 40005378 <free> <== NOT EXECUTED
400048ac: 01 00 00 00 nop <== NOT EXECUTED
400048b0: 30 bf ff e1 b,a 40004834 <partition_table_get+0x38> <== NOT EXECUTED
400048b4: 92 10 20 00 clr %o1 ! 0 <PROM_START>
400048b8: 7f ff ff 0b call 400044e4 <get_sector.part.0>
400048bc: 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)
400048c0: b0 92 20 00 orcc %o0, 0, %i0
400048c4: 12 bf ff f5 bne 40004898 <partition_table_get+0x9c> <== NEVER TAKEN
400048c8: 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) &&
400048cc: c2 0a 22 02 ldub [ %o0 + 0x202 ], %g1
400048d0: 80 a0 60 55 cmp %g1, 0x55
400048d4: 22 80 00 05 be,a 400048e8 <partition_table_get+0xec> <== ALWAYS TAKEN
400048d8: 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);
400048dc: 40 00 02 a7 call 40005378 <free> <== NOT EXECUTED
400048e0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
400048e4: 30 bf ff d4 b,a 40004834 <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) &&
400048e8: 80 a0 60 aa cmp %g1, 0xaa
400048ec: 12 bf ff fc bne 400048dc <partition_table_get+0xe0> <== NEVER TAKEN
400048f0: b4 02 21 c2 add %o0, 0x1c2, %i2
400048f4: 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;
400048f8: a0 10 00 19 mov %i1, %l0
400048fc: b8 10 20 01 mov 1, %i4
40004900: 90 10 00 1a mov %i2, %o0
40004904: 7f ff ff 0f call 40004540 <data_to_part_desc.part.1>
40004908: 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)
4000490c: b0 92 20 00 orcc %o0, 0, %i0
40004910: 12 80 00 2b bne 400049bc <partition_table_get+0x1c0> <== NEVER TAKEN
40004914: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
return rc;
}
if (part_desc != NULL)
40004918: 80 a0 60 00 cmp %g1, 0
4000491c: 22 80 00 0a be,a 40004944 <partition_table_get+0x148> <== NEVER TAKEN
40004920: 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;
40004924: c6 00 60 04 ld [ %g1 + 4 ], %g3
40004928: c4 00 60 08 ld [ %g1 + 8 ], %g2
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
4000492c: f8 28 60 02 stb %i4, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
40004930: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
40004934: 84 00 c0 02 add %g3, %g2, %g2
40004938: 84 00 bf ff add %g2, -1, %g2
4000493c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
40004940: c2 24 20 28 st %g1, [ %l0 + 0x28 ]
40004944: b8 07 20 01 inc %i4
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
40004948: 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;
4000494c: 82 0f 20 ff and %i4, 0xff, %g1
40004950: 80 a0 60 05 cmp %g1, 5
40004954: 12 bf ff eb bne 40004900 <partition_table_get+0x104>
40004958: a0 04 20 04 add %l0, 4, %l0
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
4000495c: d0 07 bf b0 ld [ %fp + -80 ], %o0
40004960: 40 00 02 86 call 40005378 <free>
40004964: b8 10 20 04 mov 4, %i4
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
40004968: 82 10 20 04 mov 4, %g1
4000496c: 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];
40004970: d4 06 e0 28 ld [ %i3 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
40004974: 80 a2 a0 00 cmp %o2, 0
40004978: 02 80 00 07 be 40004994 <partition_table_get+0x198> <== NEVER TAKEN
4000497c: 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));
40004980: 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))
40004984: 82 08 60 7f and %g1, 0x7f, %g1
40004988: 80 a0 60 05 cmp %g1, 5
4000498c: 22 80 00 06 be,a 400049a4 <partition_table_get+0x1a8>
40004990: 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;
40004994: b8 87 3f ff addcc %i4, -1, %i4
40004998: 12 bf ff f6 bne 40004970 <partition_table_get+0x174>
4000499c: b6 06 e0 04 add %i3, 4, %i3
400049a0: 30 bf ff a5 b,a 40004834 <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);
400049a4: 7f ff ff 34 call 40004674 <read_extended_partition>
400049a8: 90 10 00 1d mov %i5, %o0
free(part_desc);
400049ac: 40 00 02 73 call 40005378 <free>
400049b0: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
400049b4: 10 bf ff f8 b 40004994 <partition_table_get+0x198>
400049b8: c0 26 e0 28 clr [ %i3 + 0x28 ]
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
400049bc: 40 00 02 6f call 40005378 <free> <== NOT EXECUTED
400049c0: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
400049c4: 30 bf ff 9c b,a 40004834 <partition_table_get+0x38> <== NOT EXECUTED
40004548 <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
40004548: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
4000454c: 92 10 20 00 clr %o1
40004550: 7f ff ff 6d call 40004304 <open>
40004554: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
40004558: 80 a2 3f ff cmp %o0, -1
4000455c: 02 80 00 09 be 40004580 <pathconf+0x38> <== ALWAYS TAKEN
40004560: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
40004564: 40 00 15 3b call 40009a50 <fpathconf> <== NOT EXECUTED
40004568: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000456c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
40004570: 40 00 15 0a call 40009998 <close> <== NOT EXECUTED
40004574: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
40004578: 81 c7 e0 08 ret <== NOT EXECUTED
4000457c: 81 e8 00 00 restore <== NOT EXECUTED
}
40004580: 81 c7 e0 08 ret
40004584: 91 e8 3f ff restore %g0, -1, %o0
4000cd60 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
4000cd60: 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)
4000cd64: 92 10 21 ff mov 0x1ff, %o1
4000cd68: 11 10 00 7b sethi %hi(0x4001ec00), %o0
4000cd6c: 40 00 05 93 call 4000e3b8 <rtems_mkdir>
4000cd70: 90 12 20 c8 or %o0, 0xc8, %o0 ! 4001ecc8 <_CPU_Trap_slot_template+0x10>
4000cd74: 80 a2 20 00 cmp %o0, 0
4000cd78: 12 80 00 49 bne 4000ce9c <pipe_create+0x13c>
4000cd7c: 03 10 00 7f sethi %hi(0x4001fc00), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000cd80: d4 10 62 58 lduh [ %g1 + 0x258 ], %o2 ! 4001fe58 <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);
4000cd84: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000cd88: 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);
4000cd8c: 84 10 a1 70 or %g2, 0x170, %g2
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000cd90: c8 30 62 58 sth %g4, [ %g1 + 0x258 ]
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4000cd94: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
4000cd98: 03 00 00 19 sethi %hi(0x6400), %g1
4000cd9c: 86 10 e2 69 or %g3, 0x269, %g3
4000cda0: 82 10 62 6f or %g1, 0x26f, %g1
4000cda4: c4 3f bf f0 std %g2, [ %fp + -16 ]
4000cda8: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000cdac: 95 2a a0 10 sll %o2, 0x10, %o2
4000cdb0: 90 07 bf fa add %fp, -6, %o0
4000cdb4: 95 32 a0 10 srl %o2, 0x10, %o2
4000cdb8: 13 10 00 7b sethi %hi(0x4001ec00), %o1
4000cdbc: 40 00 12 f8 call 4001199c <sprintf>
4000cdc0: 92 12 60 d0 or %o1, 0xd0, %o1 ! 4001ecd0 <_CPU_Trap_slot_template+0x18>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4000cdc4: 90 07 bf f0 add %fp, -16, %o0
4000cdc8: 40 00 04 c8 call 4000e0e8 <mkfifo>
4000cdcc: 92 10 21 80 mov 0x180, %o1
4000cdd0: 80 a2 20 00 cmp %o0, 0
4000cdd4: 12 80 00 39 bne 4000ceb8 <pipe_create+0x158> <== NEVER TAKEN
4000cdd8: 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);
4000cddc: 7f ff dd d0 call 4000451c <open>
4000cde0: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
4000cde4: 80 a2 20 00 cmp %o0, 0
4000cde8: 06 80 00 20 bl 4000ce68 <pipe_create+0x108>
4000cdec: 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]);
4000cdf0: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000cdf4: c4 00 62 54 ld [ %g1 + 0x254 ], %g2 ! 4001f654 <rtems_libio_number_iops>
4000cdf8: 80 a2 00 02 cmp %o0, %g2
4000cdfc: 0a 80 00 14 bcs 4000ce4c <pipe_create+0xec> <== ALWAYS TAKEN
4000ce00: 82 10 20 00 clr %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4000ce04: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000ce08: 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;
4000ce0c: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000ce10: 92 10 20 01 mov 1, %o1
4000ce14: 7f ff dd c2 call 4000451c <open>
4000ce18: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4000ce1c: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
4000ce20: 80 a2 20 00 cmp %o0, 0
4000ce24: 06 80 00 18 bl 4000ce84 <pipe_create+0x124>
4000ce28: ba 10 20 00 clr %i5
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4000ce2c: 7f ff e9 c4 call 4000753c <unlink>
4000ce30: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
4000ce34: b0 10 20 00 clr %i0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
4000ce38: 80 a7 60 00 cmp %i5, 0
4000ce3c: 12 80 00 1a bne 4000cea4 <pipe_create+0x144>
4000ce40: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000ce44: 81 c7 e0 08 ret
4000ce48: 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]);
4000ce4c: 03 10 00 7f sethi %hi(0x4001fc00), %g1
4000ce50: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 4001ffd4 <rtems_libio_iops>
4000ce54: 85 2a 20 03 sll %o0, 3, %g2
4000ce58: 91 2a 20 06 sll %o0, 6, %o0
4000ce5c: 90 22 00 02 sub %o0, %g2, %o0
4000ce60: 10 bf ff e9 b 4000ce04 <pipe_create+0xa4>
4000ce64: 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;
4000ce68: 40 00 0f fb call 40010e54 <__errno>
4000ce6c: b0 10 20 00 clr %i0
4000ce70: 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);
4000ce74: 7f ff e9 b2 call 4000753c <unlink>
4000ce78: 90 07 bf f0 add %fp, -16, %o0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
4000ce7c: 10 bf ff f0 b 4000ce3c <pipe_create+0xdc>
4000ce80: 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;
4000ce84: 40 00 0f f4 call 40010e54 <__errno>
4000ce88: 01 00 00 00 nop
4000ce8c: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
4000ce90: 7f ff da 41 call 40003794 <close>
4000ce94: d0 06 00 00 ld [ %i0 ], %o0
4000ce98: 30 bf ff e5 b,a 4000ce2c <pipe_create+0xcc>
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000ce9c: 81 c7 e0 08 ret
4000cea0: 91 e8 3f ff restore %g0, -1, %o0
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
4000cea4: 40 00 0f ec call 40010e54 <__errno>
4000cea8: b0 10 3f ff mov -1, %i0
4000ceac: fa 22 00 00 st %i5, [ %o0 ]
4000ceb0: 81 c7 e0 08 ret
4000ceb4: 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){
4000ceb8: 40 00 0f e7 call 40010e54 <__errno> <== NOT EXECUTED
4000cebc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000cec0: 81 c7 e0 08 ret <== NOT EXECUTED
4000cec4: 81 e8 00 00 restore <== NOT EXECUTED
4000e378 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4000e378: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
4000e37c: 03 10 01 19 sethi %hi(0x40046400), %g1
4000e380: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <__end+0x21faf>
4000e384: 80 a6 40 01 cmp %i1, %g1
4000e388: 12 80 00 11 bne 4000e3cc <pipe_ioctl+0x54>
4000e38c: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
4000e390: 02 80 00 13 be 4000e3dc <pipe_ioctl+0x64>
4000e394: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
4000e398: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000e39c: 7f ff e9 ba call 40008a84 <rtems_semaphore_obtain>
4000e3a0: 94 10 20 00 clr %o2
4000e3a4: 80 a2 20 00 cmp %o0, 0
4000e3a8: 12 80 00 0b bne 4000e3d4 <pipe_ioctl+0x5c> <== NEVER TAKEN
4000e3ac: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000e3b0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
4000e3b4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000e3b8: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
4000e3bc: 7f ff ea 01 call 40008bc0 <rtems_semaphore_release>
4000e3c0: b0 10 20 00 clr %i0
return 0;
4000e3c4: 81 c7 e0 08 ret
4000e3c8: 81 e8 00 00 restore
}
return -EINVAL;
4000e3cc: 81 c7 e0 08 ret
4000e3d0: 91 e8 3f ea restore %g0, -22, %o0
}
4000e3d4: 81 c7 e0 08 ret <== NOT EXECUTED
4000e3d8: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4000e3dc: 81 c7 e0 08 ret
4000e3e0: 91 e8 3f f2 restore %g0, -14, %o0
4000dfb4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000dfb4: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4000dfb8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000dfbc: 92 10 20 00 clr %o1
4000dfc0: 94 10 20 00 clr %o2
4000dfc4: 7f ff ea b0 call 40008a84 <rtems_semaphore_obtain>
4000dfc8: ba 10 00 18 mov %i0, %i5
4000dfcc: 80 a2 20 00 cmp %o0, 0
4000dfd0: 12 80 00 60 bne 4000e150 <pipe_read+0x19c> <== NEVER TAKEN
4000dfd4: a0 10 20 00 clr %l0
return -EINTR;
while (read < count) {
4000dfd8: 80 a6 a0 00 cmp %i2, 0
4000dfdc: 02 80 00 53 be 4000e128 <pipe_read+0x174> <== NEVER TAKEN
4000dfe0: b0 10 20 00 clr %i0
while (PIPE_EMPTY(pipe)) {
4000dfe4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000dfe8: 80 a0 60 00 cmp %g1, 0
4000dfec: 12 80 00 29 bne 4000e090 <pipe_read+0xdc>
4000dff0: 84 26 80 10 sub %i2, %l0, %g2
/* Not an error */
if (pipe->Writers == 0)
4000dff4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000dff8: 80 a0 60 00 cmp %g1, 0
4000dffc: 02 80 00 1c be 4000e06c <pipe_read+0xb8>
4000e000: b8 10 20 00 clr %i4
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000e004: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000e008: 80 88 60 01 btst 1, %g1
4000e00c: 32 80 00 18 bne,a 4000e06c <pipe_read+0xb8>
4000e010: 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 ++;
4000e014: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
4000e018: 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 ++;
4000e01c: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000e020: 7f ff ea e8 call 40008bc0 <rtems_semaphore_release>
4000e024: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
4000e028: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e02c: 40 00 05 98 call 4000f68c <rtems_barrier_wait>
4000e030: 92 10 20 00 clr %o1
4000e034: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e038: 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))
4000e03c: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e040: 92 10 20 00 clr %o1
4000e044: 94 10 20 00 clr %o2
4000e048: 7f ff ea 8f call 40008a84 <rtems_semaphore_obtain>
4000e04c: b8 0f 3f fc and %i4, -4, %i4
4000e050: 80 a2 20 00 cmp %o0, 0
4000e054: 12 80 00 37 bne 4000e130 <pipe_read+0x17c> <== NEVER TAKEN
4000e058: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4000e05c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000e060: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000e064: 02 bf ff e0 be 4000dfe4 <pipe_read+0x30> <== ALWAYS TAKEN
4000e068: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4000e06c: 7f ff ea d5 call 40008bc0 <rtems_semaphore_release>
4000e070: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
4000e074: 80 a6 20 00 cmp %i0, 0
4000e078: 04 80 00 04 ble 4000e088 <pipe_read+0xd4>
4000e07c: 01 00 00 00 nop
return read;
return ret;
}
4000e080: 81 c7 e0 08 ret
4000e084: 81 e8 00 00 restore
4000e088: 81 c7 e0 08 ret
4000e08c: 91 e8 00 1c restore %g0, %i4, %o0
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4000e090: 80 a0 40 02 cmp %g1, %g2
4000e094: 08 80 00 03 bleu 4000e0a0 <pipe_read+0xec>
4000e098: b8 10 00 01 mov %g1, %i4
4000e09c: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - pipe->Start;
4000e0a0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e0a4: e2 07 60 04 ld [ %i5 + 4 ], %l1
4000e0a8: a2 24 40 01 sub %l1, %g1, %l1
if (chunk > chunk1) {
4000e0ac: 80 a7 00 11 cmp %i4, %l1
4000e0b0: 04 80 00 22 ble 4000e138 <pipe_read+0x184>
4000e0b4: d2 07 40 00 ld [ %i5 ], %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000e0b8: 94 10 00 11 mov %l1, %o2
4000e0bc: 92 02 40 01 add %o1, %g1, %o1
4000e0c0: 40 00 11 51 call 40012604 <memcpy>
4000e0c4: 90 06 40 10 add %i1, %l0, %o0
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000e0c8: d2 07 40 00 ld [ %i5 ], %o1
4000e0cc: 90 04 00 11 add %l0, %l1, %o0
4000e0d0: 94 27 00 11 sub %i4, %l1, %o2
4000e0d4: 40 00 11 4c call 40012604 <memcpy>
4000e0d8: 90 06 40 08 add %i1, %o0, %o0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
4000e0dc: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
4000e0e0: d2 07 60 04 ld [ %i5 + 4 ], %o1
4000e0e4: 40 00 40 4f call 4001e220 <.urem>
4000e0e8: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
4000e0ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4000e0f0: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
4000e0f4: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4000e0f8: 80 a0 60 00 cmp %g1, 0
4000e0fc: 12 80 00 03 bne 4000e108 <pipe_read+0x154>
4000e100: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
4000e104: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
4000e108: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000e10c: 80 a0 60 00 cmp %g1, 0
4000e110: 32 80 00 12 bne,a 4000e158 <pipe_read+0x1a4>
4000e114: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
4000e118: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4000e11c: 80 a6 00 1a cmp %i0, %i2
4000e120: 0a bf ff b1 bcs 4000dfe4 <pipe_read+0x30> <== NEVER TAKEN
4000e124: a0 10 00 18 mov %i0, %l0
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4000e128: 10 bf ff d1 b 4000e06c <pipe_read+0xb8>
4000e12c: 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;
4000e130: 10 bf ff d1 b 4000e074 <pipe_read+0xc0> <== NOT EXECUTED
4000e134: 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);
4000e138: 90 06 40 10 add %i1, %l0, %o0
4000e13c: 92 02 40 01 add %o1, %g1, %o1
4000e140: 40 00 11 31 call 40012604 <memcpy>
4000e144: 94 10 00 1c mov %i4, %o2
pipe->Start += chunk;
4000e148: 10 bf ff e6 b 4000e0e0 <pipe_read+0x12c>
4000e14c: d0 07 60 08 ld [ %i5 + 8 ], %o0
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4000e150: 81 c7 e0 08 ret <== NOT EXECUTED
4000e154: 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);
4000e158: 40 00 05 35 call 4000f62c <rtems_barrier_release>
4000e15c: 92 07 bf fc add %fp, -4, %o1
read += chunk;
4000e160: 10 bf ff ef b 4000e11c <pipe_read+0x168>
4000e164: b0 06 00 1c add %i0, %i4, %i0
4000da04 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000da04: 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);
4000da08: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4000da0c: 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)
4000da10: 80 88 60 02 btst 2, %g1
4000da14: 02 80 00 05 be 4000da28 <pipe_release+0x24>
4000da18: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
4000da1c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000da20: 84 00 bf ff add %g2, -1, %g2
4000da24: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000da28: 80 88 60 04 btst 4, %g1
4000da2c: 02 80 00 05 be 4000da40 <pipe_release+0x3c>
4000da30: 01 00 00 00 nop
pipe->Writers --;
4000da34: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000da38: 82 00 7f ff add %g1, -1, %g1
4000da3c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
4000da40: 7f ff ec 60 call 40008bc0 <rtems_semaphore_release>
4000da44: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000da48: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000da4c: 80 a0 60 00 cmp %g1, 0
4000da50: 02 80 00 0f be 4000da8c <pipe_release+0x88>
4000da54: 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)
4000da58: 80 a0 60 00 cmp %g1, 0
4000da5c: 12 80 00 07 bne 4000da78 <pipe_release+0x74> <== NEVER TAKEN
4000da60: 80 a7 20 02 cmp %i4, 2
4000da64: 02 80 00 06 be 4000da7c <pipe_release+0x78> <== NEVER TAKEN
4000da68: 03 10 00 8e sethi %hi(0x40023800), %g1
PIPE_WAKEUPREADERS(pipe);
4000da6c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000da70: 40 00 06 ef call 4000f62c <rtems_barrier_release>
4000da74: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000da78: 03 10 00 8e sethi %hi(0x40023800), %g1
4000da7c: 7f ff ec 51 call 40008bc0 <rtems_semaphore_release>
4000da80: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 ! 40023898 <pipe_semaphore>
4000da84: 81 c7 e0 08 ret
4000da88: 81 e8 00 00 restore
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000da8c: 80 a0 60 00 cmp %g1, 0
4000da90: 02 80 00 0c be 4000dac0 <pipe_release+0xbc>
4000da94: 80 a7 20 04 cmp %i4, 4
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000da98: 02 bf ff f9 be 4000da7c <pipe_release+0x78> <== NEVER TAKEN
4000da9c: 03 10 00 8e sethi %hi(0x40023800), %g1
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4000daa0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000daa4: 40 00 06 e2 call 4000f62c <rtems_barrier_release>
4000daa8: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000daac: 03 10 00 8e sethi %hi(0x40023800), %g1
4000dab0: 7f ff ec 44 call 40008bc0 <rtems_semaphore_release>
4000dab4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 ! 40023898 <pipe_semaphore>
4000dab8: 81 c7 e0 08 ret
4000dabc: 81 e8 00 00 restore
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
4000dac0: 40 00 06 b2 call 4000f588 <rtems_barrier_delete>
4000dac4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
rtems_barrier_delete(pipe->writeBarrier);
4000dac8: 40 00 06 b0 call 4000f588 <rtems_barrier_delete>
4000dacc: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
rtems_semaphore_delete(pipe->Semaphore);
4000dad0: 7f ff eb b6 call 400089a8 <rtems_semaphore_delete>
4000dad4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
free(pipe->Buffer);
4000dad8: 7f ff d9 8a call 40004100 <free>
4000dadc: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000dae0: 7f ff d9 88 call 40004100 <free>
4000dae4: 90 10 00 1d mov %i5, %o0
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000dae8: 03 10 00 8e sethi %hi(0x40023800), %g1
4000daec: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 ! 40023898 <pipe_semaphore>
4000daf0: 7f ff ec 34 call 40008bc0 <rtems_semaphore_release>
4000daf4: c0 26 00 00 clr [ %i0 ]
4000daf8: 81 c7 e0 08 ret
4000dafc: 81 e8 00 00 restore
4000e168 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000e168: 9d e3 bf 98 save %sp, -104, %sp
4000e16c: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000e170: 80 a6 a0 00 cmp %i2, 0
4000e174: 12 80 00 04 bne 4000e184 <pipe_write+0x1c> <== ALWAYS TAKEN
4000e178: b0 10 20 00 clr %i0
#endif
if (written > 0)
return written;
return ret;
}
4000e17c: 81 c7 e0 08 ret
4000e180: 81 e8 00 00 restore
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
4000e184: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000e188: 92 10 20 00 clr %o1
4000e18c: 7f ff ea 3e call 40008a84 <rtems_semaphore_obtain>
4000e190: 94 10 20 00 clr %o2
4000e194: 80 a2 20 00 cmp %o0, 0
4000e198: 12 80 00 6c bne 4000e348 <pipe_write+0x1e0> <== NEVER TAKEN
4000e19c: 01 00 00 00 nop
return -EINTR;
if (pipe->Readers == 0) {
4000e1a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e1a4: 80 a0 60 00 cmp %g1, 0
4000e1a8: 22 80 00 54 be,a 4000e2f8 <pipe_write+0x190>
4000e1ac: 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;
4000e1b0: f8 07 60 04 ld [ %i5 + 4 ], %i4
4000e1b4: 80 a6 80 1c cmp %i2, %i4
4000e1b8: 08 80 00 5b bleu 4000e324 <pipe_write+0x1bc> <== ALWAYS TAKEN
4000e1bc: a0 10 20 01 mov 1, %l0
4000e1c0: a2 10 20 00 clr %l1
4000e1c4: b0 10 20 00 clr %i0
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000e1c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000e1cc: 84 27 00 01 sub %i4, %g1, %g2
4000e1d0: 80 a0 80 10 cmp %g2, %l0
4000e1d4: 1a 80 00 27 bcc 4000e270 <pipe_write+0x108>
4000e1d8: 86 26 80 11 sub %i2, %l1, %g3
if (LIBIO_NODELAY(iop)) {
4000e1dc: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000e1e0: 80 88 60 01 btst 1, %g1
4000e1e4: 32 80 00 53 bne,a 4000e330 <pipe_write+0x1c8>
4000e1e8: 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 ++;
4000e1ec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
4000e1f0: 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 ++;
4000e1f4: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000e1f8: 7f ff ea 72 call 40008bc0 <rtems_semaphore_release>
4000e1fc: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
4000e200: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000e204: 40 00 05 22 call 4000f68c <rtems_barrier_wait>
4000e208: 92 10 20 00 clr %o1
4000e20c: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e210: 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))
4000e214: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000e218: 92 10 20 00 clr %o1
4000e21c: 94 10 20 00 clr %o2
4000e220: 7f ff ea 19 call 40008a84 <rtems_semaphore_obtain>
4000e224: b8 0f 3f fc and %i4, -4, %i4
4000e228: 80 a2 20 00 cmp %o0, 0
4000e22c: 12 80 00 45 bne 4000e340 <pipe_write+0x1d8> <== NEVER TAKEN
4000e230: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4000e234: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000e238: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000e23c: 12 80 00 3d bne 4000e330 <pipe_write+0x1c8> <== NEVER TAKEN
4000e240: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
4000e244: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000e248: 80 a0 60 00 cmp %g1, 0
4000e24c: 22 80 00 2b be,a 4000e2f8 <pipe_write+0x190> <== NEVER TAKEN
4000e250: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
4000e254: 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) {
4000e258: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000e25c: 84 27 00 01 sub %i4, %g1, %g2
4000e260: 80 a0 80 10 cmp %g2, %l0
4000e264: 2a bf ff df bcs,a 4000e1e0 <pipe_write+0x78> <== NEVER TAKEN
4000e268: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000e26c: 86 26 80 11 sub %i2, %l1, %g3
4000e270: 80 a0 80 03 cmp %g2, %g3
4000e274: 08 80 00 03 bleu 4000e280 <pipe_write+0x118>
4000e278: a0 10 00 02 mov %g2, %l0
4000e27c: a0 10 00 03 mov %g3, %l0
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000e280: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000e284: 92 10 00 1c mov %i4, %o1
4000e288: 40 00 3f e6 call 4001e220 <.urem>
4000e28c: 90 00 40 08 add %g1, %o0, %o0
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000e290: c2 07 40 00 ld [ %i5 ], %g1
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000e294: b8 27 00 08 sub %i4, %o0, %i4
if (chunk > chunk1) {
4000e298: 80 a4 00 1c cmp %l0, %i4
4000e29c: 04 80 00 2d ble 4000e350 <pipe_write+0x1e8>
4000e2a0: 92 06 40 11 add %i1, %l1, %o1
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000e2a4: 94 10 00 1c mov %i4, %o2
4000e2a8: 40 00 10 d7 call 40012604 <memcpy>
4000e2ac: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000e2b0: d0 07 40 00 ld [ %i5 ], %o0
4000e2b4: 92 07 00 11 add %i4, %l1, %o1
4000e2b8: 94 24 00 1c sub %l0, %i4, %o2
4000e2bc: 40 00 10 d2 call 40012604 <memcpy>
4000e2c0: 92 06 40 09 add %i1, %o1, %o1
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
4000e2c4: c4 07 60 0c ld [ %i5 + 0xc ], %g2
if (pipe->waitingReaders > 0)
4000e2c8: 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;
4000e2cc: 84 00 80 10 add %g2, %l0, %g2
if (pipe->waitingReaders > 0)
4000e2d0: 80 a0 60 00 cmp %g1, 0
4000e2d4: 12 80 00 24 bne 4000e364 <pipe_write+0x1fc>
4000e2d8: c4 27 60 0c st %g2, [ %i5 + 0xc ]
PIPE_WAKEUPREADERS(pipe);
written += chunk;
4000e2dc: 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) {
4000e2e0: 80 a6 80 18 cmp %i2, %i0
4000e2e4: 08 80 00 12 bleu 4000e32c <pipe_write+0x1c4> <== ALWAYS TAKEN
4000e2e8: a2 10 00 18 mov %i0, %l1
4000e2ec: 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;
4000e2f0: 10 bf ff b6 b 4000e1c8 <pipe_write+0x60> <== NOT EXECUTED
4000e2f4: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
}
out_locked:
PIPE_UNLOCK(pipe);
4000e2f8: 7f ff ea 32 call 40008bc0 <rtems_semaphore_release>
4000e2fc: b8 10 3f e0 mov -32, %i4
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
4000e300: 40 00 01 19 call 4000e764 <getpid>
4000e304: 01 00 00 00 nop
4000e308: 40 00 02 98 call 4000ed68 <kill>
4000e30c: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
4000e310: 80 a6 20 00 cmp %i0, 0
4000e314: 14 bf ff 9a bg 4000e17c <pipe_write+0x14>
4000e318: 01 00 00 00 nop
4000e31c: 81 c7 e0 08 ret
4000e320: 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;
4000e324: 10 bf ff a7 b 4000e1c0 <pipe_write+0x58>
4000e328: a0 10 00 1a mov %i2, %l0
while (written < count) {
4000e32c: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4000e330: 7f ff ea 24 call 40008bc0 <rtems_semaphore_release>
4000e334: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000e338: 10 bf ff f7 b 4000e314 <pipe_write+0x1ac>
4000e33c: 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;
4000e340: 10 bf ff f4 b 4000e310 <pipe_write+0x1a8> <== NOT EXECUTED
4000e344: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4000e348: 81 c7 e0 08 ret <== NOT EXECUTED
4000e34c: 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);
4000e350: 90 00 40 08 add %g1, %o0, %o0
4000e354: 40 00 10 ac call 40012604 <memcpy>
4000e358: 94 10 00 10 mov %l0, %o2
pipe->Length += chunk;
4000e35c: 10 bf ff db b 4000e2c8 <pipe_write+0x160>
4000e360: c4 07 60 0c ld [ %i5 + 0xc ], %g2
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
4000e364: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000e368: 40 00 04 b1 call 4000f62c <rtems_barrier_release>
4000e36c: 92 07 bf fc add %fp, -4, %o1
written += chunk;
4000e370: 10 bf ff dc b 4000e2e0 <pipe_write+0x178>
4000e374: b0 06 00 10 add %i0, %l0, %i0
400083ec <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
400083ec: 05 10 00 98 sethi %hi(0x40026000), %g2
400083f0: 84 10 a0 80 or %g2, 0x80, %g2 ! 40026080 <rtems_malloc_statistics>
400083f4: c6 00 a0 08 ld [ %g2 + 8 ], %g3
400083f8: 86 00 e0 01 inc %g3
400083fc: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40008400: 84 02 7f ff add %o1, -1, %g2
40008404: 80 88 80 09 btst %g2, %o1
40008408: 02 80 00 04 be 40008418 <posix_memalign+0x2c> <== ALWAYS TAKEN
4000840c: 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 );
}
40008410: 81 c3 e0 08 retl
40008414: 90 10 20 16 mov 0x16, %o0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40008418: 08 bf ff fe bleu 40008410 <posix_memalign+0x24>
4000841c: 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 );
40008420: 82 13 c0 00 mov %o7, %g1
40008424: 40 00 00 89 call 40008648 <rtems_memalign>
40008428: 9e 10 40 00 mov %g1, %o7
4000be40 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4000be40: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
4000be44: 80 a0 60 00 cmp %g1, 0
4000be48: 02 80 00 06 be 4000be60 <pthread_attr_setschedpolicy+0x20>
4000be4c: 90 10 20 16 mov 0x16, %o0
4000be50: c4 00 40 00 ld [ %g1 ], %g2
4000be54: 80 a0 a0 00 cmp %g2, 0
4000be58: 12 80 00 04 bne 4000be68 <pthread_attr_setschedpolicy+0x28>
4000be5c: 80 a2 60 04 cmp %o1, 4
return 0;
default:
return ENOTSUP;
}
}
4000be60: 81 c3 e0 08 retl
4000be64: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
4000be68: 18 80 00 09 bgu 4000be8c <pthread_attr_setschedpolicy+0x4c>
4000be6c: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
4000be70: 85 28 80 09 sll %g2, %o1, %g2
4000be74: 80 88 a0 17 btst 0x17, %g2
4000be78: 02 80 00 05 be 4000be8c <pthread_attr_setschedpolicy+0x4c><== NEVER TAKEN
4000be7c: 01 00 00 00 nop
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4000be80: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
return 0;
4000be84: 81 c3 e0 08 retl
4000be88: 90 10 20 00 clr %o0
default:
return ENOTSUP;
}
}
4000be8c: 81 c3 e0 08 retl
4000be90: 90 10 20 86 mov 0x86, %o0
400072d4 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
400072d4: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
400072d8: 80 a6 20 00 cmp %i0, 0
400072dc: 02 80 00 04 be 400072ec <pthread_barrier_init+0x18>
400072e0: 80 a6 a0 00 cmp %i2, 0
return EINVAL;
if ( count == 0 )
400072e4: 12 80 00 04 bne 400072f4 <pthread_barrier_init+0x20>
400072e8: 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;
}
400072ec: 81 c7 e0 08 ret
400072f0: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
400072f4: 02 80 00 23 be 40007380 <pthread_barrier_init+0xac>
400072f8: 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 )
400072fc: c2 06 40 00 ld [ %i1 ], %g1
40007300: 80 a0 60 00 cmp %g1, 0
40007304: 02 bf ff fa be 400072ec <pthread_barrier_init+0x18>
40007308: 01 00 00 00 nop
return EINVAL;
switch ( the_attr->process_shared ) {
4000730c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007310: 80 a0 60 00 cmp %g1, 0
40007314: 12 bf ff f6 bne 400072ec <pthread_barrier_init+0x18> <== NEVER TAKEN
40007318: 03 10 00 60 sethi %hi(0x40018000), %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;
4000731c: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 400180f0 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
40007320: c0 27 bf f0 clr [ %fp + -16 ]
++level;
40007324: 84 00 a0 01 inc %g2
the_attributes.maximum_count = count;
40007328: f4 27 bf f4 st %i2, [ %fp + -12 ]
_Thread_Dispatch_disable_level = level;
4000732c: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ]
* 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 *)
40007330: 39 10 00 61 sethi %hi(0x40018400), %i4
40007334: 40 00 08 ee call 400096ec <_Objects_Allocate>
40007338: 90 17 20 74 or %i4, 0x74, %o0 ! 40018474 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
4000733c: ba 92 20 00 orcc %o0, 0, %i5
40007340: 02 80 00 14 be 40007390 <pthread_barrier_init+0xbc>
40007344: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
40007348: 40 00 06 37 call 40008c24 <_CORE_barrier_Initialize>
4000734c: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007350: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007354: b8 17 20 74 or %i4, 0x74, %i4
40007358: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
4000735c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007360: 85 28 a0 02 sll %g2, 2, %g2
40007364: 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;
40007368: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
4000736c: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40007370: 40 00 0d f4 call 4000ab40 <_Thread_Enable_dispatch>
40007374: b0 10 20 00 clr %i0
40007378: 81 c7 e0 08 ret
4000737c: 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 );
40007380: 7f ff ff 9c call 400071f0 <pthread_barrierattr_init>
40007384: 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 )
40007388: 10 bf ff de b 40007300 <pthread_barrier_init+0x2c>
4000738c: c2 06 40 00 ld [ %i1 ], %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
40007390: 40 00 0d ec call 4000ab40 <_Thread_Enable_dispatch>
40007394: b0 10 20 0b mov 0xb, %i0
40007398: 81 c7 e0 08 ret
4000739c: 81 e8 00 00 restore
40006b68 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
40006b68: 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 )
40006b6c: 80 a6 20 00 cmp %i0, 0
40006b70: 02 80 00 13 be 40006bbc <pthread_cleanup_push+0x54>
40006b74: 03 10 00 61 sethi %hi(0x40018400), %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;
40006b78: c4 00 62 10 ld [ %g1 + 0x210 ], %g2 ! 40018610 <_Thread_Dispatch_disable_level>
++level;
40006b7c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40006b80: c4 20 62 10 st %g2, [ %g1 + 0x210 ]
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
40006b84: 40 00 12 bc call 4000b674 <_Workspace_Allocate>
40006b88: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
40006b8c: 80 a2 20 00 cmp %o0, 0
40006b90: 02 80 00 09 be 40006bb4 <pthread_cleanup_push+0x4c> <== NEVER TAKEN
40006b94: 03 10 00 62 sethi %hi(0x40018800), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40006b98: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 40018b30 <_Per_CPU_Information+0x10>
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
40006b9c: 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;
40006ba0: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
handler->routine = routine;
40006ba4: f0 22 20 08 st %i0, [ %o0 + 8 ]
handler->arg = arg;
40006ba8: f2 22 20 0c st %i1, [ %o0 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
40006bac: 40 00 06 67 call 40008548 <_Chain_Append>
40006bb0: 90 00 60 e4 add %g1, 0xe4, %o0
}
_Thread_Enable_dispatch();
40006bb4: 40 00 0e 33 call 4000a480 <_Thread_Enable_dispatch>
40006bb8: 81 e8 00 00 restore
40006bbc: 81 c7 e0 08 ret
40006bc0: 81 e8 00 00 restore
40007b08 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
40007b08: 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;
40007b0c: 80 a6 60 00 cmp %i1, 0
40007b10: 22 80 00 27 be,a 40007bac <pthread_cond_init+0xa4>
40007b14: 33 10 00 5f sethi %hi(0x40017c00), %i1
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
40007b18: c4 06 60 04 ld [ %i1 + 4 ], %g2 ! 40017c04 <rtems_filesystem_default_pathconf+0x20>
40007b1c: 80 a0 a0 01 cmp %g2, 1
40007b20: 02 80 00 06 be 40007b38 <pthread_cond_init+0x30> <== NEVER TAKEN
40007b24: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
40007b28: c4 06 40 00 ld [ %i1 ], %g2
40007b2c: 80 a0 a0 00 cmp %g2, 0
40007b30: 32 80 00 04 bne,a 40007b40 <pthread_cond_init+0x38>
40007b34: 03 10 00 64 sethi %hi(0x40019000), %g1
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
40007b38: 81 c7 e0 08 ret
40007b3c: 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;
40007b40: c4 00 63 30 ld [ %g1 + 0x330 ], %g2
++level;
40007b44: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007b48: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
40007b4c: 39 10 00 65 sethi %hi(0x40019400), %i4
40007b50: 40 00 0a 9e call 4000a5c8 <_Objects_Allocate>
40007b54: 90 17 23 4c or %i4, 0x34c, %o0 ! 4001974c <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
40007b58: ba 92 20 00 orcc %o0, 0, %i5
40007b5c: 02 80 00 16 be 40007bb4 <pthread_cond_init+0xac>
40007b60: 90 07 60 18 add %i5, 0x18, %o0
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
40007b64: c2 06 60 04 ld [ %i1 + 4 ], %g1
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
40007b68: 92 10 20 00 clr %o1
40007b6c: 15 04 00 02 sethi %hi(0x10000800), %o2
40007b70: 96 10 20 74 mov 0x74, %o3
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
40007b74: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
40007b78: 40 00 11 c8 call 4000c298 <_Thread_queue_Initialize>
40007b7c: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007b80: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007b84: b8 17 23 4c or %i4, 0x34c, %i4
40007b88: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007b8c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007b90: 85 28 a0 02 sll %g2, 2, %g2
40007b94: 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;
40007b98: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
40007b9c: 40 00 0f a0 call 4000ba1c <_Thread_Enable_dispatch>
40007ba0: c2 26 00 00 st %g1, [ %i0 ]
return 0;
40007ba4: 10 bf ff e5 b 40007b38 <pthread_cond_init+0x30>
40007ba8: 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;
40007bac: 10 bf ff db b 40007b18 <pthread_cond_init+0x10>
40007bb0: b2 16 60 e4 or %i1, 0xe4, %i1
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
40007bb4: 40 00 0f 9a call 4000ba1c <_Thread_Enable_dispatch>
40007bb8: 01 00 00 00 nop
return ENOMEM;
40007bbc: 10 bf ff df b 40007b38 <pthread_cond_init+0x30>
40007bc0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
4000796c <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
4000796c: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
40007970: 80 a0 60 00 cmp %g1, 0
40007974: 02 80 00 06 be 4000798c <pthread_condattr_destroy+0x20>
40007978: 90 10 20 16 mov 0x16, %o0
4000797c: c4 00 40 00 ld [ %g1 ], %g2
40007980: 80 a0 a0 00 cmp %g2, 0
40007984: 32 80 00 04 bne,a 40007994 <pthread_condattr_destroy+0x28><== ALWAYS TAKEN
40007988: c0 20 40 00 clr [ %g1 ]
return EINVAL;
attr->is_initialized = false;
return 0;
}
4000798c: 81 c3 e0 08 retl
40007990: 01 00 00 00 nop
40007994: 81 c3 e0 08 retl
40007998: 90 10 20 00 clr %o0 ! 0 <PROM_START>
40007014 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
40007014: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
40007018: 80 a6 a0 00 cmp %i2, 0
4000701c: 02 80 00 0a be 40007044 <pthread_create+0x30>
40007020: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40007024: 80 a6 60 00 cmp %i1, 0
40007028: 22 80 00 63 be,a 400071b4 <pthread_create+0x1a0>
4000702c: 33 10 00 78 sethi %hi(0x4001e000), %i1
if ( !the_attr->is_initialized )
40007030: c2 06 40 00 ld [ %i1 ], %g1
40007034: 80 a0 60 00 cmp %g1, 0
40007038: 32 80 00 05 bne,a 4000704c <pthread_create+0x38>
4000703c: c2 06 60 04 ld [ %i1 + 4 ], %g1
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
40007040: ba 10 20 16 mov 0x16, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
40007044: 81 c7 e0 08 ret
40007048: 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) )
4000704c: 80 a0 60 00 cmp %g1, 0
40007050: 02 80 00 07 be 4000706c <pthread_create+0x58>
40007054: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40007058: c4 06 60 08 ld [ %i1 + 8 ], %g2
4000705c: c2 00 62 00 ld [ %g1 + 0x200 ], %g1
40007060: 80 a0 80 01 cmp %g2, %g1
40007064: 0a bf ff f8 bcs 40007044 <pthread_create+0x30>
40007068: 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 ) {
4000706c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40007070: 80 a0 60 01 cmp %g1, 1
40007074: 02 80 00 52 be 400071bc <pthread_create+0x1a8>
40007078: 80 a0 60 02 cmp %g1, 2
4000707c: 32 bf ff f2 bne,a 40007044 <pthread_create+0x30>
40007080: ba 10 20 16 mov 0x16, %i5
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
40007084: da 06 60 18 ld [ %i1 + 0x18 ], %o5
40007088: de 06 60 1c ld [ %i1 + 0x1c ], %o7
4000708c: fa 06 60 20 ld [ %i1 + 0x20 ], %i5
40007090: c8 06 60 24 ld [ %i1 + 0x24 ], %g4
40007094: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
40007098: c4 06 60 2c ld [ %i1 + 0x2c ], %g2
4000709c: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
400070a0: f8 06 60 14 ld [ %i1 + 0x14 ], %i4
schedparam = the_attr->schedparam;
400070a4: da 27 bf e4 st %o5, [ %fp + -28 ]
400070a8: de 27 bf e8 st %o7, [ %fp + -24 ]
400070ac: fa 27 bf ec st %i5, [ %fp + -20 ]
400070b0: c8 27 bf f0 st %g4, [ %fp + -16 ]
400070b4: c6 27 bf f4 st %g3, [ %fp + -12 ]
400070b8: c4 27 bf f8 st %g2, [ %fp + -8 ]
400070bc: 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 )
400070c0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400070c4: 80 a0 60 00 cmp %g1, 0
400070c8: 12 bf ff df bne 40007044 <pthread_create+0x30>
400070cc: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
400070d0: 40 00 19 e7 call 4000d86c <_POSIX_Priority_Is_valid>
400070d4: d0 07 bf e4 ld [ %fp + -28 ], %o0
400070d8: 80 8a 20 ff btst 0xff, %o0
400070dc: 02 bf ff da be 40007044 <pthread_create+0x30> <== NEVER TAKEN
400070e0: 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);
400070e4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
400070e8: e0 07 bf e4 ld [ %fp + -28 ], %l0
400070ec: e8 08 61 fc ldub [ %g1 + 0x1fc ], %l4
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
400070f0: 90 10 00 1c mov %i4, %o0
400070f4: 92 07 bf e4 add %fp, -28, %o1
400070f8: 94 07 bf dc add %fp, -36, %o2
400070fc: 40 00 19 e9 call 4000d8a0 <_POSIX_Thread_Translate_sched_param>
40007100: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
40007104: ba 92 20 00 orcc %o0, 0, %i5
40007108: 12 bf ff cf bne 40007044 <pthread_create+0x30>
4000710c: 25 10 00 7e sethi %hi(0x4001f800), %l2
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
40007110: d0 04 a2 30 ld [ %l2 + 0x230 ], %o0 ! 4001fa30 <_RTEMS_Allocator_Mutex>
40007114: 40 00 06 99 call 40008b78 <_API_Mutex_Lock>
40007118: 27 10 00 7e sethi %hi(0x4001f800), %l3
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
4000711c: 40 00 09 70 call 400096dc <_Objects_Allocate>
40007120: 90 14 e3 b4 or %l3, 0x3b4, %o0 ! 4001fbb4 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
40007124: a2 92 20 00 orcc %o0, 0, %l1
40007128: 02 80 00 1f be 400071a4 <pthread_create+0x190>
4000712c: 05 10 00 7b sethi %hi(0x4001ec00), %g2
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
40007130: 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 )
40007134: d6 00 a2 00 ld [ %g2 + 0x200 ], %o3
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
40007138: c0 27 bf d4 clr [ %fp + -44 ]
4000713c: 97 2a e0 01 sll %o3, 1, %o3
40007140: 80 a2 c0 01 cmp %o3, %g1
40007144: 1a 80 00 03 bcc 40007150 <pthread_create+0x13c>
40007148: d4 06 60 04 ld [ %i1 + 4 ], %o2
4000714c: 96 10 00 01 mov %g1, %o3
40007150: c2 07 bf dc ld [ %fp + -36 ], %g1
40007154: 9a 0d 20 ff and %l4, 0xff, %o5
40007158: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000715c: 82 10 20 01 mov 1, %g1
40007160: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40007164: c2 07 bf e0 ld [ %fp + -32 ], %g1
40007168: c0 23 a0 68 clr [ %sp + 0x68 ]
4000716c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40007170: 82 07 bf d4 add %fp, -44, %g1
40007174: 90 14 e3 b4 or %l3, 0x3b4, %o0
40007178: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
4000717c: 92 10 00 11 mov %l1, %o1
40007180: 98 10 20 00 clr %o4
40007184: 40 00 0e a2 call 4000ac0c <_Thread_Initialize>
40007188: 9a 23 40 10 sub %o5, %l0, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
4000718c: 80 8a 20 ff btst 0xff, %o0
40007190: 12 80 00 1e bne 40007208 <pthread_create+0x1f4>
40007194: 11 10 00 7e sethi %hi(0x4001f800), %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
40007198: 92 10 00 11 mov %l1, %o1
4000719c: 40 00 0a 48 call 40009abc <_Objects_Free>
400071a0: 90 12 23 b4 or %o0, 0x3b4, %o0
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
400071a4: d0 04 a2 30 ld [ %l2 + 0x230 ], %o0
400071a8: 40 00 06 89 call 40008bcc <_API_Mutex_Unlock>
400071ac: ba 10 20 0b mov 0xb, %i5
400071b0: 30 bf ff a5 b,a 40007044 <pthread_create+0x30>
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
400071b4: 10 bf ff 9f b 40007030 <pthread_create+0x1c>
400071b8: b2 16 61 dc or %i1, 0x1dc, %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 ];
400071bc: 03 10 00 7f sethi %hi(0x4001fc00), %g1
400071c0: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 4001fed0 <_Per_CPU_Information+0x10>
400071c4: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
400071c8: d8 00 60 88 ld [ %g1 + 0x88 ], %o4
400071cc: da 00 60 8c ld [ %g1 + 0x8c ], %o5
400071d0: de 00 60 90 ld [ %g1 + 0x90 ], %o7
400071d4: fa 00 60 94 ld [ %g1 + 0x94 ], %i5
400071d8: c8 00 60 98 ld [ %g1 + 0x98 ], %g4
400071dc: c6 00 60 9c ld [ %g1 + 0x9c ], %g3
400071e0: 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;
400071e4: f8 00 60 84 ld [ %g1 + 0x84 ], %i4
schedparam = api->schedparam;
400071e8: d8 27 bf e4 st %o4, [ %fp + -28 ]
400071ec: da 27 bf e8 st %o5, [ %fp + -24 ]
400071f0: de 27 bf ec st %o7, [ %fp + -20 ]
400071f4: fa 27 bf f0 st %i5, [ %fp + -16 ]
400071f8: c8 27 bf f4 st %g4, [ %fp + -12 ]
400071fc: c6 27 bf f8 st %g3, [ %fp + -8 ]
break;
40007200: 10 bf ff b0 b 400070c0 <pthread_create+0xac>
40007204: c4 27 bf fc st %g2, [ %fp + -4 ]
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40007208: e0 04 61 50 ld [ %l1 + 0x150 ], %l0
api->Attributes = *the_attr;
4000720c: 92 10 00 19 mov %i1, %o1
40007210: 94 10 20 40 mov 0x40, %o2
40007214: 40 00 25 ed call 400109c8 <memcpy>
40007218: 90 10 00 10 mov %l0, %o0
api->detachstate = the_attr->detachstate;
4000721c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
40007220: 92 07 bf e4 add %fp, -28, %o1
40007224: 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;
40007228: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
api->schedpolicy = schedpolicy;
4000722c: f8 24 20 84 st %i4, [ %l0 + 0x84 ]
api->schedparam = schedparam;
40007230: 40 00 25 e6 call 400109c8 <memcpy>
40007234: 90 04 20 88 add %l0, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
40007238: 90 10 00 11 mov %l1, %o0
4000723c: 92 10 20 01 mov 1, %o1
40007240: 94 10 00 1a mov %i2, %o2
40007244: 96 10 00 1b mov %i3, %o3
40007248: 40 00 10 d3 call 4000b594 <_Thread_Start>
4000724c: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
40007250: 80 a7 20 04 cmp %i4, 4
40007254: 02 80 00 07 be 40007270 <pthread_create+0x25c>
40007258: 01 00 00 00 nop
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
4000725c: c2 04 60 08 ld [ %l1 + 8 ], %g1
_RTEMS_Unlock_allocator();
40007260: d0 04 a2 30 ld [ %l2 + 0x230 ], %o0
40007264: 40 00 06 5a call 40008bcc <_API_Mutex_Unlock>
40007268: c2 26 00 00 st %g1, [ %i0 ]
4000726c: 30 bf ff 76 b,a 40007044 <pthread_create+0x30>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
40007270: 40 00 10 f3 call 4000b63c <_Timespec_To_ticks>
40007274: 90 04 20 90 add %l0, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40007278: 92 04 20 a8 add %l0, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000727c: d0 24 20 b4 st %o0, [ %l0 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40007280: 11 10 00 7e sethi %hi(0x4001f800), %o0
40007284: 40 00 11 a8 call 4000b924 <_Watchdog_Insert>
40007288: 90 12 22 48 or %o0, 0x248, %o0 ! 4001fa48 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
4000728c: 10 bf ff f5 b 40007260 <pthread_create+0x24c>
40007290: c2 04 60 08 ld [ %l1 + 8 ], %g1
4001be5c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
4001be5c: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
4001be60: 80 a6 60 00 cmp %i1, 0
4001be64: 02 80 00 31 be 4001bf28 <pthread_kill+0xcc>
4001be68: b8 06 7f ff add %i1, -1, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001be6c: 80 a7 20 1f cmp %i4, 0x1f
4001be70: 18 80 00 2e bgu 4001bf28 <pthread_kill+0xcc>
4001be74: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
4001be78: 7f ff b8 20 call 40009ef8 <_Thread_Get>
4001be7c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4001be80: c2 07 bf fc ld [ %fp + -4 ], %g1
4001be84: 80 a0 60 00 cmp %g1, 0
4001be88: 12 80 00 2e bne 4001bf40 <pthread_kill+0xe4> <== NEVER TAKEN
4001be8c: ba 10 00 08 mov %o0, %i5
4001be90: 11 10 00 79 sethi %hi(0x4001e400), %o0
4001be94: 7f ff af b9 call 40007d78 <_API_extensions_Add_post_switch>
4001be98: 90 12 20 a8 or %o0, 0xa8, %o0 ! 4001e4a8 <_POSIX_signals_Post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
4001be9c: 83 2e 60 02 sll %i1, 2, %g1
4001bea0: 85 2e 60 04 sll %i1, 4, %g2
4001bea4: 84 20 80 01 sub %g2, %g1, %g2
4001bea8: 03 10 00 7d sethi %hi(0x4001f400), %g1
4001beac: 82 10 60 30 or %g1, 0x30, %g1 ! 4001f430 <_POSIX_signals_Vectors>
4001beb0: 82 00 40 02 add %g1, %g2, %g1
4001beb4: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001beb8: 80 a0 a0 01 cmp %g2, 1
4001bebc: 02 80 00 15 be 4001bf10 <pthread_kill+0xb4>
4001bec0: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001bec4: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
4001bec8: b6 10 20 01 mov 1, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001becc: 90 10 00 1d mov %i5, %o0
4001bed0: b9 2e c0 1c sll %i3, %i4, %i4
4001bed4: 92 10 00 19 mov %i1, %o1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001bed8: b8 10 80 1c or %g2, %i4, %i4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001bedc: 94 10 20 00 clr %o2
4001bee0: 7f ff ff 86 call 4001bcf8 <_POSIX_signals_Unblock_thread>
4001bee4: f8 20 60 d4 st %i4, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001bee8: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001beec: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 4001f3d0 <_Per_CPU_Information>
4001bef0: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001bef4: 80 a0 a0 00 cmp %g2, 0
4001bef8: 02 80 00 06 be 4001bf10 <pthread_kill+0xb4>
4001befc: 01 00 00 00 nop
4001bf00: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001bf04: 80 a7 40 02 cmp %i5, %g2
4001bf08: 02 80 00 06 be 4001bf20 <pthread_kill+0xc4>
4001bf0c: 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();
4001bf10: 7f ff b7 ee call 40009ec8 <_Thread_Enable_dispatch>
4001bf14: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4001bf18: 81 c7 e0 08 ret
4001bf1c: 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;
4001bf20: f6 28 60 0c stb %i3, [ %g1 + 0xc ]
4001bf24: 30 bf ff fb b,a 4001bf10 <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 );
4001bf28: 7f ff ce 06 call 4000f740 <__errno>
4001bf2c: b0 10 3f ff mov -1, %i0
4001bf30: 82 10 20 16 mov 0x16, %g1
4001bf34: c2 22 00 00 st %g1, [ %o0 ]
4001bf38: 81 c7 e0 08 ret
4001bf3c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
4001bf40: 7f ff ce 00 call 4000f740 <__errno> <== NOT EXECUTED
4001bf44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001bf48: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
4001bf4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
4001bf50: 81 c7 e0 08 ret <== NOT EXECUTED
4001bf54: 81 e8 00 00 restore <== NOT EXECUTED
40009054 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
40009054: 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 );
40009058: 90 10 00 19 mov %i1, %o0
4000905c: 40 00 00 38 call 4000913c <_POSIX_Absolute_timeout_to_ticks>
40009060: 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 );
40009064: 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 );
40009068: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
4000906c: 80 a7 60 03 cmp %i5, 3
40009070: 02 80 00 0c be 400090a0 <pthread_mutex_timedlock+0x4c>
40009074: 90 10 00 18 mov %i0, %o0
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
40009078: 7f ff ff bd call 40008f6c <_POSIX_Mutex_Lock_support>
4000907c: 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) ) {
40009080: 80 a2 20 10 cmp %o0, 0x10
40009084: 12 80 00 0a bne 400090ac <pthread_mutex_timedlock+0x58>
40009088: b0 10 00 08 mov %o0, %i0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
4000908c: 80 a7 60 00 cmp %i5, 0
40009090: 12 80 00 09 bne 400090b4 <pthread_mutex_timedlock+0x60> <== ALWAYS TAKEN
40009094: ba 07 7f ff add %i5, -1, %i5
return EINVAL;
40009098: 81 c7 e0 08 ret <== NOT EXECUTED
4000909c: 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 );
400090a0: 7f ff ff b3 call 40008f6c <_POSIX_Mutex_Lock_support>
400090a4: 92 10 20 01 mov 1, %o1
400090a8: b0 10 00 08 mov %o0, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
400090ac: 81 c7 e0 08 ret
400090b0: 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 ||
400090b4: 80 a7 60 01 cmp %i5, 1
400090b8: 18 bf ff fd bgu 400090ac <pthread_mutex_timedlock+0x58> <== NEVER TAKEN
400090bc: 01 00 00 00 nop
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
400090c0: 81 c7 e0 08 ret
400090c4: 91 e8 20 74 restore %g0, 0x74, %o0
40006918 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
40006918: 82 10 00 08 mov %o0, %g1
if ( !attr )
4000691c: 80 a0 60 00 cmp %g1, 0
40006920: 02 80 00 06 be 40006938 <pthread_mutexattr_gettype+0x20>
40006924: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
40006928: c4 00 40 00 ld [ %g1 ], %g2
4000692c: 80 a0 a0 00 cmp %g2, 0
40006930: 12 80 00 04 bne 40006940 <pthread_mutexattr_gettype+0x28>
40006934: 80 a2 60 00 cmp %o1, 0
if ( !type )
return EINVAL;
*type = attr->type;
return 0;
}
40006938: 81 c3 e0 08 retl
4000693c: 01 00 00 00 nop
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
40006940: 02 bf ff fe be 40006938 <pthread_mutexattr_gettype+0x20> <== NEVER TAKEN
40006944: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
40006948: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
4000694c: 90 10 20 00 clr %o0
}
40006950: 81 c3 e0 08 retl
40006954: c2 22 40 00 st %g1, [ %o1 ]
40008c20 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
40008c20: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
40008c24: 80 a0 60 00 cmp %g1, 0
40008c28: 02 80 00 06 be 40008c40 <pthread_mutexattr_setpshared+0x20>
40008c2c: 90 10 20 16 mov 0x16, %o0
40008c30: c4 00 40 00 ld [ %g1 ], %g2
40008c34: 80 a0 a0 00 cmp %g2, 0
40008c38: 12 80 00 04 bne 40008c48 <pthread_mutexattr_setpshared+0x28>
40008c3c: 80 a2 60 01 cmp %o1, 1
return 0;
default:
return EINVAL;
}
}
40008c40: 81 c3 e0 08 retl
40008c44: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
40008c48: 18 bf ff fe bgu 40008c40 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
40008c4c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
40008c50: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
default:
return EINVAL;
}
}
40008c54: 81 c3 e0 08 retl
40008c58: 90 10 20 00 clr %o0
400069ac <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
400069ac: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
400069b0: 80 a0 60 00 cmp %g1, 0
400069b4: 02 80 00 06 be 400069cc <pthread_mutexattr_settype+0x20>
400069b8: 90 10 20 16 mov 0x16, %o0
400069bc: c4 00 40 00 ld [ %g1 ], %g2
400069c0: 80 a0 a0 00 cmp %g2, 0
400069c4: 12 80 00 04 bne 400069d4 <pthread_mutexattr_settype+0x28> <== ALWAYS TAKEN
400069c8: 80 a2 60 03 cmp %o1, 3
return 0;
default:
return EINVAL;
}
}
400069cc: 81 c3 e0 08 retl
400069d0: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( type ) {
400069d4: 18 bf ff fe bgu 400069cc <pthread_mutexattr_settype+0x20>
400069d8: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
400069dc: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
default:
return EINVAL;
}
}
400069e0: 81 c3 e0 08 retl
400069e4: 90 10 20 00 clr %o0
40007748 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
40007748: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
4000774c: 80 a6 60 00 cmp %i1, 0
40007750: 12 80 00 05 bne 40007764 <pthread_once+0x1c>
40007754: 80 a6 20 00 cmp %i0, 0
return EINVAL;
40007758: 82 10 20 16 mov 0x16, %g1
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
4000775c: 81 c7 e0 08 ret
40007760: 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 )
40007764: 22 bf ff fe be,a 4000775c <pthread_once+0x14>
40007768: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !once_control->init_executed ) {
4000776c: c4 06 20 04 ld [ %i0 + 4 ], %g2
40007770: 80 a0 a0 00 cmp %g2, 0
40007774: 12 bf ff fa bne 4000775c <pthread_once+0x14>
40007778: 82 10 20 00 clr %g1
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
4000777c: 90 10 21 00 mov 0x100, %o0
40007780: 92 10 21 00 mov 0x100, %o1
40007784: 40 00 03 21 call 40008408 <rtems_task_mode>
40007788: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
4000778c: c2 06 20 04 ld [ %i0 + 4 ], %g1
40007790: 80 a0 60 00 cmp %g1, 0
40007794: 02 80 00 09 be 400077b8 <pthread_once+0x70> <== ALWAYS TAKEN
40007798: 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);
4000779c: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
400077a0: 92 10 21 00 mov 0x100, %o1
400077a4: 40 00 03 19 call 40008408 <rtems_task_mode>
400077a8: 94 07 bf fc add %fp, -4, %o2
}
return 0;
400077ac: 82 10 20 00 clr %g1
}
400077b0: 81 c7 e0 08 ret
400077b4: 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;
400077b8: c2 26 00 00 st %g1, [ %i0 ]
once_control->init_executed = true;
(*init_routine)();
400077bc: 9f c6 40 00 call %i1
400077c0: c2 26 20 04 st %g1, [ %i0 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
400077c4: 10 bf ff f7 b 400077a0 <pthread_once+0x58>
400077c8: d0 07 bf fc ld [ %fp + -4 ], %o0
40007990 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
40007990: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
40007994: 80 a6 20 00 cmp %i0, 0
40007998: 02 80 00 08 be 400079b8 <pthread_rwlock_init+0x28>
4000799c: 80 a6 60 00 cmp %i1, 0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
400079a0: 02 80 00 23 be 40007a2c <pthread_rwlock_init+0x9c>
400079a4: 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 )
400079a8: c2 06 40 00 ld [ %i1 ], %g1
400079ac: 80 a0 60 00 cmp %g1, 0
400079b0: 32 80 00 04 bne,a 400079c0 <pthread_rwlock_init+0x30> <== ALWAYS TAKEN
400079b4: c2 06 60 04 ld [ %i1 + 4 ], %g1
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
400079b8: 81 c7 e0 08 ret
400079bc: 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 ) {
400079c0: 80 a0 60 00 cmp %g1, 0
400079c4: 12 bf ff fd bne 400079b8 <pthread_rwlock_init+0x28> <== NEVER TAKEN
400079c8: 03 10 00 8e sethi %hi(0x40023800), %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;
400079cc: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 400238c0 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
400079d0: c0 27 bf f4 clr [ %fp + -12 ]
++level;
400079d4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400079d8: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
* 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 *)
400079dc: 39 10 00 8e sethi %hi(0x40023800), %i4
400079e0: 40 00 0b 14 call 4000a630 <_Objects_Allocate>
400079e4: 90 17 22 c4 or %i4, 0x2c4, %o0 ! 40023ac4 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
400079e8: ba 92 20 00 orcc %o0, 0, %i5
400079ec: 02 80 00 14 be 40007a3c <pthread_rwlock_init+0xac>
400079f0: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
400079f4: 40 00 09 5f call 40009f70 <_CORE_RWLock_Initialize>
400079f8: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400079fc: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007a00: b8 17 22 c4 or %i4, 0x2c4, %i4
40007a04: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40007a08: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007a0c: 85 28 a0 02 sll %g2, 2, %g2
40007a10: 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;
40007a14: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
40007a18: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40007a1c: 40 00 10 51 call 4000bb60 <_Thread_Enable_dispatch>
40007a20: b0 10 20 00 clr %i0
40007a24: 81 c7 e0 08 ret
40007a28: 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 );
40007a2c: 40 00 01 b6 call 40008104 <pthread_rwlockattr_init>
40007a30: 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 )
40007a34: 10 bf ff de b 400079ac <pthread_rwlock_init+0x1c>
40007a38: c2 06 40 00 ld [ %i1 ], %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
40007a3c: 40 00 10 49 call 4000bb60 <_Thread_Enable_dispatch>
40007a40: b0 10 20 0b mov 0xb, %i0
40007a44: 81 c7 e0 08 ret
40007a48: 81 e8 00 00 restore
40007fa0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40007fa0: 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 )
40007fa4: 80 a6 20 00 cmp %i0, 0
40007fa8: 02 80 00 25 be 4000803c <pthread_rwlock_timedrdlock+0x9c>
40007fac: 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 );
40007fb0: 40 00 1a 80 call 4000e9b0 <_POSIX_Absolute_timeout_to_ticks>
40007fb4: 90 10 00 19 mov %i1, %o0
40007fb8: d2 06 00 00 ld [ %i0 ], %o1
40007fbc: ba 10 00 08 mov %o0, %i5
40007fc0: 94 07 bf f8 add %fp, -8, %o2
40007fc4: 11 10 00 6a sethi %hi(0x4001a800), %o0
40007fc8: 40 00 0b b8 call 4000aea8 <_Objects_Get>
40007fcc: 90 12 21 a4 or %o0, 0x1a4, %o0 ! 4001a9a4 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40007fd0: c2 07 bf f8 ld [ %fp + -8 ], %g1
40007fd4: 80 a0 60 00 cmp %g1, 0
40007fd8: 32 80 00 1a bne,a 40008040 <pthread_rwlock_timedrdlock+0xa0>
40007fdc: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
40007fe0: d2 06 00 00 ld [ %i0 ], %o1
40007fe4: 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 )
40007fe8: 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(
40007fec: 90 02 20 10 add %o0, 0x10, %o0
40007ff0: 80 a0 00 01 cmp %g0, %g1
40007ff4: 98 10 20 00 clr %o4
40007ff8: b8 60 3f ff subx %g0, -1, %i4
40007ffc: 40 00 07 f6 call 40009fd4 <_CORE_RWLock_Obtain_for_reading>
40008000: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
40008004: 40 00 0f 60 call 4000bd84 <_Thread_Enable_dispatch>
40008008: 01 00 00 00 nop
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
4000800c: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40008010: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4001ad00 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
40008014: 80 a7 20 00 cmp %i4, 0
40008018: 12 80 00 05 bne 4000802c <pthread_rwlock_timedrdlock+0x8c>
4000801c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
40008020: 80 a2 20 02 cmp %o0, 2
40008024: 02 80 00 09 be 40008048 <pthread_rwlock_timedrdlock+0xa8>
40008028: 80 a7 60 00 cmp %i5, 0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
4000802c: 40 00 00 3f call 40008128 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40008030: 01 00 00 00 nop
40008034: 81 c7 e0 08 ret
40008038: 91 e8 00 08 restore %g0, %o0, %o0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
4000803c: b0 10 20 16 mov 0x16, %i0
}
40008040: 81 c7 e0 08 ret
40008044: 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 )
40008048: 22 bf ff fe be,a 40008040 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
4000804c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40008050: ba 07 7f ff add %i5, -1, %i5
40008054: 80 a7 60 01 cmp %i5, 1
40008058: 18 bf ff f5 bgu 4000802c <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
4000805c: b0 10 20 74 mov 0x74, %i0
40008060: 30 bf ff f8 b,a 40008040 <pthread_rwlock_timedrdlock+0xa0>
40008064 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40008064: 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 )
40008068: 80 a6 20 00 cmp %i0, 0
4000806c: 02 80 00 25 be 40008100 <pthread_rwlock_timedwrlock+0x9c>
40008070: 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 );
40008074: 40 00 1a 4f call 4000e9b0 <_POSIX_Absolute_timeout_to_ticks>
40008078: 90 10 00 19 mov %i1, %o0
4000807c: d2 06 00 00 ld [ %i0 ], %o1
40008080: ba 10 00 08 mov %o0, %i5
40008084: 94 07 bf f8 add %fp, -8, %o2
40008088: 11 10 00 6a sethi %hi(0x4001a800), %o0
4000808c: 40 00 0b 87 call 4000aea8 <_Objects_Get>
40008090: 90 12 21 a4 or %o0, 0x1a4, %o0 ! 4001a9a4 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40008094: c2 07 bf f8 ld [ %fp + -8 ], %g1
40008098: 80 a0 60 00 cmp %g1, 0
4000809c: 32 80 00 1a bne,a 40008104 <pthread_rwlock_timedwrlock+0xa0>
400080a0: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
400080a4: d2 06 00 00 ld [ %i0 ], %o1
400080a8: 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 )
400080ac: 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(
400080b0: 90 02 20 10 add %o0, 0x10, %o0
400080b4: 80 a0 00 01 cmp %g0, %g1
400080b8: 98 10 20 00 clr %o4
400080bc: b8 60 3f ff subx %g0, -1, %i4
400080c0: 40 00 07 fa call 4000a0a8 <_CORE_RWLock_Obtain_for_writing>
400080c4: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
400080c8: 40 00 0f 2f call 4000bd84 <_Thread_Enable_dispatch>
400080cc: 01 00 00 00 nop
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
400080d0: 03 10 00 6b sethi %hi(0x4001ac00), %g1
400080d4: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4001ad00 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
400080d8: 80 a7 20 00 cmp %i4, 0
400080dc: 12 80 00 05 bne 400080f0 <pthread_rwlock_timedwrlock+0x8c>
400080e0: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
400080e4: 80 a2 20 02 cmp %o0, 2
400080e8: 02 80 00 09 be 4000810c <pthread_rwlock_timedwrlock+0xa8>
400080ec: 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(
400080f0: 40 00 00 0e call 40008128 <_POSIX_RWLock_Translate_core_RWLock_return_code>
400080f4: 01 00 00 00 nop
400080f8: 81 c7 e0 08 ret
400080fc: 91 e8 00 08 restore %g0, %o0, %o0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
40008100: b0 10 20 16 mov 0x16, %i0
}
40008104: 81 c7 e0 08 ret
40008108: 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 )
4000810c: 22 bf ff fe be,a 40008104 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
40008110: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40008114: ba 07 7f ff add %i5, -1, %i5
40008118: 80 a7 60 01 cmp %i5, 1
4000811c: 18 bf ff f5 bgu 400080f0 <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
40008120: b0 10 20 74 mov 0x74, %i0
40008124: 30 bf ff f8 b,a 40008104 <pthread_rwlock_timedwrlock+0xa0>
40008940 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
40008940: 82 10 00 08 mov %o0, %g1
if ( !attr )
40008944: 80 a0 60 00 cmp %g1, 0
40008948: 02 80 00 06 be 40008960 <pthread_rwlockattr_setpshared+0x20>
4000894c: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
40008950: c4 00 40 00 ld [ %g1 ], %g2
40008954: 80 a0 a0 00 cmp %g2, 0
40008958: 12 80 00 04 bne 40008968 <pthread_rwlockattr_setpshared+0x28>
4000895c: 80 a2 60 01 cmp %o1, 1
return 0;
default:
return EINVAL;
}
}
40008960: 81 c3 e0 08 retl
40008964: 01 00 00 00 nop
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
40008968: 18 bf ff fe bgu 40008960 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
4000896c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
40008970: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
default:
return EINVAL;
}
}
40008974: 81 c3 e0 08 retl
40008978: 90 10 20 00 clr %o0
40009a00 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
40009a00: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
40009a04: 80 a6 a0 00 cmp %i2, 0
40009a08: 02 80 00 0a be 40009a30 <pthread_setschedparam+0x30>
40009a0c: ba 10 20 16 mov 0x16, %i5
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
40009a10: 90 10 00 19 mov %i1, %o0
40009a14: 92 10 00 1a mov %i2, %o1
40009a18: 94 07 bf f4 add %fp, -12, %o2
40009a1c: 40 00 18 52 call 4000fb64 <_POSIX_Thread_Translate_sched_param>
40009a20: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
40009a24: ba 92 20 00 orcc %o0, 0, %i5
40009a28: 02 80 00 05 be 40009a3c <pthread_setschedparam+0x3c>
40009a2c: 90 10 00 18 mov %i0, %o0
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
40009a30: b0 10 00 1d mov %i5, %i0
40009a34: 81 c7 e0 08 ret
40009a38: 81 e8 00 00 restore
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
40009a3c: 40 00 0c b3 call 4000cd08 <_Thread_Get>
40009a40: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40009a44: c2 07 bf fc ld [ %fp + -4 ], %g1
40009a48: 80 a0 60 00 cmp %g1, 0
40009a4c: 12 80 00 2b bne 40009af8 <pthread_setschedparam+0xf8>
40009a50: b6 10 00 08 mov %o0, %i3
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40009a54: f8 02 21 50 ld [ %o0 + 0x150 ], %i4
if ( api->schedpolicy == SCHED_SPORADIC )
40009a58: c2 07 20 84 ld [ %i4 + 0x84 ], %g1
40009a5c: 80 a0 60 04 cmp %g1, 4
40009a60: 02 80 00 35 be 40009b34 <pthread_setschedparam+0x134>
40009a64: 01 00 00 00 nop
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
40009a68: c2 06 80 00 ld [ %i2 ], %g1
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
40009a6c: 80 a6 60 00 cmp %i1, 0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
40009a70: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
40009a74: c4 06 a0 04 ld [ %i2 + 4 ], %g2
40009a78: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
40009a7c: 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;
40009a80: f2 27 20 84 st %i1, [ %i4 + 0x84 ]
api->schedparam = *param;
40009a84: c4 27 20 90 st %g2, [ %i4 + 0x90 ]
40009a88: c4 06 a0 0c ld [ %i2 + 0xc ], %g2
40009a8c: c4 27 20 94 st %g2, [ %i4 + 0x94 ]
40009a90: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2
40009a94: c4 27 20 98 st %g2, [ %i4 + 0x98 ]
40009a98: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
40009a9c: c4 27 20 9c st %g2, [ %i4 + 0x9c ]
40009aa0: c4 06 a0 18 ld [ %i2 + 0x18 ], %g2
40009aa4: c4 27 20 a0 st %g2, [ %i4 + 0xa0 ]
the_thread->budget_algorithm = budget_algorithm;
40009aa8: c4 07 bf f4 ld [ %fp + -12 ], %g2
40009aac: c4 26 e0 78 st %g2, [ %i3 + 0x78 ]
the_thread->budget_callout = budget_callout;
40009ab0: c4 07 bf f8 ld [ %fp + -8 ], %g2
switch ( api->schedpolicy ) {
40009ab4: 06 80 00 0e bl 40009aec <pthread_setschedparam+0xec> <== NEVER TAKEN
40009ab8: c4 26 e0 7c st %g2, [ %i3 + 0x7c ]
40009abc: 80 a6 60 02 cmp %i1, 2
40009ac0: 04 80 00 11 ble 40009b04 <pthread_setschedparam+0x104>
40009ac4: 07 10 00 6d sethi %hi(0x4001b400), %g3
40009ac8: 80 a6 60 04 cmp %i1, 4
40009acc: 12 80 00 08 bne 40009aec <pthread_setschedparam+0xec> <== NEVER TAKEN
40009ad0: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
40009ad4: c2 27 20 a4 st %g1, [ %i4 + 0xa4 ]
_Watchdog_Remove( &api->Sporadic_timer );
40009ad8: 40 00 10 b0 call 4000dd98 <_Watchdog_Remove>
40009adc: 90 07 20 a8 add %i4, 0xa8, %o0
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
40009ae0: 90 10 20 00 clr %o0
40009ae4: 7f ff ff 7b call 400098d0 <_POSIX_Threads_Sporadic_budget_TSR>
40009ae8: 92 10 00 1b mov %i3, %o1
break;
}
_Thread_Enable_dispatch();
40009aec: 40 00 0c 7b call 4000ccd8 <_Thread_Enable_dispatch>
40009af0: b0 10 00 1d mov %i5, %i0
40009af4: 30 bf ff d0 b,a 40009a34 <pthread_setschedparam+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
40009af8: ba 10 20 03 mov 3, %i5
}
40009afc: 81 c7 e0 08 ret
40009b00: 91 e8 00 1d restore %g0, %i5, %o0
40009b04: d2 08 e0 5c ldub [ %g3 + 0x5c ], %o1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
40009b08: 05 10 00 6f sethi %hi(0x4001bc00), %g2
40009b0c: c4 00 a3 d0 ld [ %g2 + 0x3d0 ], %g2 ! 4001bfd0 <_Thread_Ticks_per_timeslice>
40009b10: 92 22 40 01 sub %o1, %g1, %o1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
40009b14: 90 10 00 1b mov %i3, %o0
40009b18: 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;
40009b1c: c4 26 e0 74 st %g2, [ %i3 + 0x74 ]
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
40009b20: 40 00 0b 34 call 4000c7f0 <_Thread_Change_priority>
40009b24: 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();
40009b28: 40 00 0c 6c call 4000ccd8 <_Thread_Enable_dispatch>
40009b2c: b0 10 00 1d mov %i5, %i0
40009b30: 30 bf ff c1 b,a 40009a34 <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 );
40009b34: 40 00 10 99 call 4000dd98 <_Watchdog_Remove>
40009b38: 90 07 20 a8 add %i4, 0xa8, %o0
api->schedpolicy = policy;
api->schedparam = *param;
40009b3c: 10 bf ff cc b 40009a6c <pthread_setschedparam+0x6c>
40009b40: c2 06 80 00 ld [ %i2 ], %g1
40007398 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
40007398: 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() )
4000739c: 3b 10 00 62 sethi %hi(0x40018800), %i5
400073a0: ba 17 63 20 or %i5, 0x320, %i5 ! 40018b20 <_Per_CPU_Information>
400073a4: c2 07 60 08 ld [ %i5 + 8 ], %g1
400073a8: 80 a0 60 00 cmp %g1, 0
400073ac: 12 80 00 16 bne 40007404 <pthread_testcancel+0x6c> <== NEVER TAKEN
400073b0: 03 10 00 61 sethi %hi(0x40018400), %g1
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
400073b4: 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;
400073b8: c6 00 62 10 ld [ %g1 + 0x210 ], %g3
400073bc: c4 00 a1 50 ld [ %g2 + 0x150 ], %g2
++level;
400073c0: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
400073c4: c6 20 62 10 st %g3, [ %g1 + 0x210 ]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
400073c8: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1
400073cc: 80 a0 60 00 cmp %g1, 0
400073d0: 12 80 00 0b bne 400073fc <pthread_testcancel+0x64> <== NEVER TAKEN
400073d4: 01 00 00 00 nop
400073d8: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1
400073dc: 80 a0 60 00 cmp %g1, 0
400073e0: 02 80 00 07 be 400073fc <pthread_testcancel+0x64>
400073e4: 01 00 00 00 nop
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
400073e8: 40 00 0c 26 call 4000a480 <_Thread_Enable_dispatch>
400073ec: b2 10 3f ff mov -1, %i1 ! ffffffff <LEON_REG+0x7fffffff>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
400073f0: f0 07 60 10 ld [ %i5 + 0x10 ], %i0
400073f4: 40 00 17 ef call 4000d3b0 <_POSIX_Thread_Exit>
400073f8: 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();
400073fc: 40 00 0c 21 call 4000a480 <_Thread_Enable_dispatch>
40007400: 81 e8 00 00 restore
40007404: 81 c7 e0 08 ret <== NOT EXECUTED
40007408: 81 e8 00 00 restore <== NOT EXECUTED
4000c5ac <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
4000c5ac: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
4000c5b0: 7f ff df f0 call 40004570 <malloc>
4000c5b4: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
4000c5b8: ba 92 20 00 orcc %o0, 0, %i5
4000c5bc: 02 80 00 0b be 4000c5e8 <ramdisk_allocate+0x3c> <== NEVER TAKEN
4000c5c0: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
4000c5c4: 02 80 00 0b be 4000c5f0 <ramdisk_allocate+0x44>
4000c5c8: 90 10 00 1a mov %i2, %o0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
4000c5cc: 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;
4000c5d0: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
4000c5d4: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = media_block_count;
4000c5d8: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
4000c5dc: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
4000c5e0: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
4000c5e4: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
4000c5e8: 81 c7 e0 08 ret
4000c5ec: 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);
4000c5f0: 7f ff de 61 call 40003f74 <calloc>
4000c5f4: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
4000c5f8: b0 92 20 00 orcc %o0, 0, %i0
4000c5fc: 02 80 00 04 be 4000c60c <ramdisk_allocate+0x60> <== NEVER TAKEN
4000c600: 82 10 20 01 mov 1, %g1
free(rd);
return NULL;
}
rd->malloced = true;
4000c604: 10 bf ff f4 b 4000c5d4 <ramdisk_allocate+0x28>
4000c608: 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);
4000c60c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000c610: 7f ff de 90 call 40004050 <free> <== NOT EXECUTED
4000c614: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
4000c618: 30 bf ff f4 b,a 4000c5e8 <ramdisk_allocate+0x3c> <== NOT EXECUTED
4000c61c <ramdisk_free>:
return rd;
}
void ramdisk_free(ramdisk *rd)
{
4000c61c: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
4000c620: 80 a6 20 00 cmp %i0, 0
4000c624: 02 80 00 0c be 4000c654 <ramdisk_free+0x38> <== NEVER TAKEN
4000c628: 01 00 00 00 nop
if (rd->malloced) {
4000c62c: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
4000c630: 80 a0 60 00 cmp %g1, 0
4000c634: 12 80 00 04 bne 4000c644 <ramdisk_free+0x28>
4000c638: 01 00 00 00 nop
free(rd->area);
}
free(rd);
4000c63c: 7f ff de 85 call 40004050 <free>
4000c640: 81 e8 00 00 restore
void ramdisk_free(ramdisk *rd)
{
if (rd != NULL) {
if (rd->malloced) {
free(rd->area);
4000c644: 7f ff de 83 call 40004050 <free>
4000c648: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
4000c64c: 7f ff de 81 call 40004050 <free>
4000c650: 81 e8 00 00 restore
4000c654: 81 c7 e0 08 ret <== NOT EXECUTED
4000c658: 81 e8 00 00 restore <== NOT EXECUTED
4000dac0 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
4000dac0: 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();
4000dac4: 7f ff da 0e call 400042fc <rtems_disk_io_initialize>
4000dac8: a0 10 00 18 mov %i0, %l0
if (rc != RTEMS_SUCCESSFUL)
4000dacc: b0 92 20 00 orcc %o0, 0, %i0
4000dad0: 02 80 00 04 be 4000dae0 <ramdisk_initialize+0x20> <== ALWAYS TAKEN
4000dad4: 23 10 00 99 sethi %hi(0x40026400), %l1
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
}
4000dad8: 81 c7 e0 08 ret <== NOT EXECUTED
4000dadc: 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));
4000dae0: fa 04 62 2c ld [ %l1 + 0x22c ], %i5
4000dae4: 92 10 20 10 mov 0x10, %o1
4000dae8: 7f ff dd ed call 4000529c <calloc>
4000daec: 90 10 00 1d mov %i5, %o0
r->trace = false;
4000daf0: c0 2a 20 0e clrb [ %o0 + 0xe ]
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000daf4: 80 a7 60 00 cmp %i5, 0
4000daf8: 02 80 00 2e be 4000dbb0 <ramdisk_initialize+0xf0> <== NEVER TAKEN
4000dafc: b6 10 00 08 mov %o0, %i3
4000db00: 35 10 00 99 sethi %hi(0x40026400), %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000db04: 39 0b d9 19 sethi %hi(0x2f646400), %i4
4000db08: 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,
4000db0c: 25 10 00 36 sethi %hi(0x4000d800), %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++)
4000db10: b4 16 a2 30 or %i2, 0x230, %i2
4000db14: b2 10 20 00 clr %i1
4000db18: a2 14 62 2c or %l1, 0x22c, %l1
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000db1c: b8 17 21 76 or %i4, 0x176, %i4
4000db20: 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);
4000db24: 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,
4000db28: a4 14 a3 fc or %l2, 0x3fc, %l2
}
}
else
{
r->malloced = false;
r->initialized = true;
4000db2c: 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;
4000db30: d4 06 80 00 ld [ %i2 ], %o2
r->block_num = c->block_num;
4000db34: d6 06 a0 04 ld [ %i2 + 4 ], %o3
if (c->location == NULL)
4000db38: 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;
4000db3c: f2 2f bf f8 stb %i1, [ %fp + -8 ]
r->block_size = c->block_size;
4000db40: d4 26 c0 00 st %o2, [ %i3 ]
r->block_num = c->block_num;
4000db44: d6 26 e0 04 st %o3, [ %i3 + 4 ]
if (c->location == NULL)
4000db48: 80 a0 60 00 cmp %g1, 0
4000db4c: 02 80 00 1f be 4000dbc8 <ramdisk_initialize+0x108> <== ALWAYS TAKEN
4000db50: f8 3f bf f0 std %i4, [ %fp + -16 ]
r->initialized = true;
}
}
else
{
r->malloced = false;
4000db54: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
4000db58: f0 2e e0 0c stb %i0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
4000db5c: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
4000db60: 92 10 00 19 mov %i1, %o1
4000db64: 9a 10 00 1b mov %i3, %o5
4000db68: 98 10 00 12 mov %l2, %o4
4000db6c: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
4000db70: 7f ff d9 43 call 4000407c <rtems_disk_create_phys>
4000db74: 90 10 00 10 mov %l0, %o0
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
4000db78: 80 a2 20 00 cmp %o0, 0
4000db7c: 22 80 00 08 be,a 4000db9c <ramdisk_initialize+0xdc> <== ALWAYS TAKEN
4000db80: c2 04 40 00 ld [ %l1 ], %g1
{
if (r->malloced)
4000db84: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
4000db88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000db8c: 12 80 00 0b bne 4000dbb8 <ramdisk_initialize+0xf8> <== NOT EXECUTED
4000db90: 01 00 00 00 nop <== NOT EXECUTED
{
free(r->area);
}
r->initialized = false;
4000db94: 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++)
4000db98: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
4000db9c: b2 06 60 01 inc %i1
4000dba0: b4 06 a0 0c add %i2, 0xc, %i2
4000dba4: 80 a0 40 19 cmp %g1, %i1
4000dba8: 18 bf ff e2 bgu 4000db30 <ramdisk_initialize+0x70> <== NEVER TAKEN
4000dbac: b6 06 e0 10 add %i3, 0x10, %i3
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
4000dbb0: 81 c7 e0 08 ret
4000dbb4: 91 e8 20 00 restore %g0, 0, %o0
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
{
if (r->malloced)
{
free(r->area);
4000dbb8: 7f ff dd f0 call 40005378 <free> <== NOT EXECUTED
4000dbbc: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
4000dbc0: 10 bf ff f6 b 4000db98 <ramdisk_initialize+0xd8> <== NOT EXECUTED
4000dbc4: 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);
4000dbc8: 92 10 00 0a mov %o2, %o1
4000dbcc: 90 10 00 0b mov %o3, %o0
4000dbd0: d4 3f bf e8 std %o2, [ %fp + -24 ]
4000dbd4: 40 00 4f e5 call 40021b68 <.umul>
4000dbd8: f0 2e e0 0d stb %i0, [ %i3 + 0xd ]
4000dbdc: 7f ff df 84 call 400059ec <malloc>
4000dbe0: 01 00 00 00 nop
4000dbe4: d0 26 e0 08 st %o0, [ %i3 + 8 ]
if (r->area == NULL) /* No enough memory for this disk */
4000dbe8: 80 a2 20 00 cmp %o0, 0
4000dbec: 02 bf ff ea be 4000db94 <ramdisk_initialize+0xd4> <== NEVER TAKEN
4000dbf0: d4 1f bf e8 ldd [ %fp + -24 ], %o2
r->initialized = false;
continue;
}
else
{
r->initialized = true;
4000dbf4: 10 bf ff db b 4000db60 <ramdisk_initialize+0xa0>
4000dbf8: f0 2e e0 0c stb %i0, [ %i3 + 0xc ]
4000c464 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000c464: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000c468: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000c46c: b8 10 00 1a mov %i2, %i4
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000c470: 84 10 a2 07 or %g2, 0x207, %g2
4000c474: 80 a6 40 02 cmp %i1, %g2
4000c478: 02 80 00 09 be 4000c49c <ramdisk_ioctl+0x38>
4000c47c: f6 06 20 3c ld [ %i0 + 0x3c ], %i3
4000c480: 05 30 06 10 sethi %hi(0xc0184000), %g2
4000c484: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <LEON_REG+0x40184201>
4000c488: 80 a6 40 02 cmp %i1, %g2
4000c48c: 22 80 00 0e be,a 4000c4c4 <ramdisk_ioctl+0x60>
4000c490: c2 06 80 00 ld [ %i2 ], %g1
ramdisk_free(rd);
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
4000c494: 40 00 0b 08 call 4000f0b4 <rtems_blkdev_ioctl>
4000c498: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
4000c49c: c2 0e e0 0f ldub [ %i3 + 0xf ], %g1
4000c4a0: 80 a0 60 00 cmp %g1, 0
4000c4a4: 12 80 00 3f bne 4000c5a0 <ramdisk_ioctl+0x13c>
4000c4a8: 01 00 00 00 nop
default:
return rtems_blkdev_ioctl (dd, req, argp);
break;
}
errno = EINVAL;
4000c4ac: 40 00 1e 5a call 40013e14 <__errno>
4000c4b0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
4000c4b4: 82 10 20 16 mov 0x16, %g1
4000c4b8: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
4000c4bc: 81 c7 e0 08 ret
4000c4c0: 81 e8 00 00 restore
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
4000c4c4: 80 a0 60 00 cmp %g1, 0
4000c4c8: 12 80 00 1c bne 4000c538 <ramdisk_ioctl+0xd4>
4000c4cc: 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++)
4000c4d0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000c4d4: 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;
4000c4d8: 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++)
4000c4dc: 80 a0 60 00 cmp %g1, 0
4000c4e0: 02 80 00 0f be 4000c51c <ramdisk_ioctl+0xb8> <== NEVER TAKEN
4000c4e4: 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);
4000c4e8: d0 07 40 00 ld [ %i5 ], %o0
4000c4ec: d2 06 c0 00 ld [ %i3 ], %o1
4000c4f0: 40 00 2b 98 call 40017350 <.umul>
4000c4f4: f2 07 60 08 ld [ %i5 + 8 ], %i1
4000c4f8: d4 07 60 04 ld [ %i5 + 4 ], %o2
4000c4fc: 92 06 00 08 add %i0, %o0, %o1
4000c500: 40 00 20 7c call 400146f0 <memcpy>
4000c504: 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++)
4000c508: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000c50c: b4 06 a0 01 inc %i2
4000c510: 80 a6 80 01 cmp %i2, %g1
4000c514: 0a bf ff f5 bcs 4000c4e8 <ramdisk_ioctl+0x84> <== NEVER TAKEN
4000c518: 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);
4000c51c: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000c520: 90 10 00 1c mov %i4, %o0
4000c524: 92 10 20 00 clr %o1
4000c528: 9f c0 40 00 call %g1
4000c52c: 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);
4000c530: 81 c7 e0 08 ret
4000c534: 81 e8 00 00 restore
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
4000c538: 12 bf ff dd bne 4000c4ac <ramdisk_ioctl+0x48> <== NEVER TAKEN
4000c53c: 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++)
4000c540: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
4000c544: 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++)
4000c548: 80 a0 60 00 cmp %g1, 0
4000c54c: 02 bf ff f4 be 4000c51c <ramdisk_ioctl+0xb8> <== NEVER TAKEN
4000c550: 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);
4000c554: d0 07 40 00 ld [ %i5 ], %o0
4000c558: d2 06 c0 00 ld [ %i3 ], %o1
4000c55c: 40 00 2b 7d call 40017350 <.umul>
4000c560: b4 06 a0 01 inc %i2
4000c564: d2 07 60 08 ld [ %i5 + 8 ], %o1
4000c568: d4 07 60 04 ld [ %i5 + 4 ], %o2
4000c56c: 40 00 20 61 call 400146f0 <memcpy>
4000c570: 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++)
4000c574: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000c578: 80 a6 80 01 cmp %i2, %g1
4000c57c: 0a bf ff f6 bcs 4000c554 <ramdisk_ioctl+0xf0>
4000c580: ba 07 60 10 add %i5, 0x10, %i5
4000c584: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000c588: 90 10 00 1c mov %i4, %o0
4000c58c: 92 10 20 00 clr %o1
4000c590: 9f c0 40 00 call %g1
4000c594: 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);
4000c598: 81 c7 e0 08 ret
4000c59c: 81 e8 00 00 restore
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
ramdisk_free(rd);
4000c5a0: 40 00 00 1f call 4000c61c <ramdisk_free>
4000c5a4: 90 10 00 1b mov %i3, %o0
4000c5a8: 30 bf ff c1 b,a 4000c4ac <ramdisk_ioctl+0x48>
4000c65c <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
4000c65c: 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);
4000c660: 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;
4000c664: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
4000c668: 94 07 bf fc add %fp, -4, %o2
4000c66c: 13 10 00 67 sethi %hi(0x40019c00), %o1
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
4000c670: 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);
4000c674: 7f ff f1 fe call 40008e6c <rtems_io_register_driver>
4000c678: 92 12 62 40 or %o1, 0x240, %o1
if (sc != RTEMS_SUCCESSFUL) {
4000c67c: 80 a2 20 00 cmp %o0, 0
4000c680: 02 80 00 04 be 4000c690 <ramdisk_register+0x34> <== ALWAYS TAKEN
4000c684: 96 10 00 1a mov %i2, %o3
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
4000c688: 81 c7 e0 08 ret
4000c68c: 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);
4000c690: 92 10 00 18 mov %i0, %o1
4000c694: 7f ff ff c6 call 4000c5ac <ramdisk_allocate>
4000c698: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
4000c69c: b4 92 20 00 orcc %o0, 0, %i2
4000c6a0: 02 80 00 14 be 4000c6f0 <ramdisk_register+0x94> <== NEVER TAKEN
4000c6a4: e0 07 bf fc ld [ %fp + -4 ], %l0
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
4000c6a8: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000c6ac: 90 10 00 10 mov %l0, %o0
4000c6b0: 92 10 20 00 clr %o1
4000c6b4: 94 10 00 18 mov %i0, %o2
4000c6b8: 96 10 00 19 mov %i1, %o3
4000c6bc: 9a 10 00 1a mov %i2, %o5
4000c6c0: 19 10 00 31 sethi %hi(0x4000c400), %o4
4000c6c4: 7f ff db 4a call 400033ec <rtems_disk_create_phys>
4000c6c8: 98 13 20 64 or %o4, 0x64, %o4 ! 4000c464 <ramdisk_ioctl>
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
4000c6cc: 80 a2 20 00 cmp %o0, 0
4000c6d0: 12 80 00 06 bne 4000c6e8 <ramdisk_register+0x8c> <== NEVER TAKEN
4000c6d4: 01 00 00 00 nop
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
4000c6d8: e0 27 00 00 st %l0, [ %i4 ]
4000c6dc: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
4000c6e0: 10 bf ff ea b 4000c688 <ramdisk_register+0x2c>
4000c6e4: ba 10 20 00 clr %i5
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ramdisk_free(rd);
4000c6e8: 7f ff ff cd call 4000c61c <ramdisk_free> <== NOT EXECUTED
4000c6ec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
4000c6f0: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
4000c6f4: 7f ff f2 43 call 40009000 <rtems_io_unregister_driver> <== NOT EXECUTED
4000c6f8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
4000c6fc: 81 c7 e0 08 ret <== NOT EXECUTED
4000c700: 81 e8 00 00 restore <== NOT EXECUTED
4000c704: 40 00 d7 80 call 40042504 <__end+0x26704> <== NOT EXECUTED
4000c708: 40 00 d9 1c call 40042b78 <__end+0x26d78> <== NOT EXECUTED
4000c70c: 40 00 d9 14 call 40042b5c <__end+0x26d5c> <== NOT EXECUTED
4000c710: 40 00 d9 00 call 40042b10 <__end+0x26d10> <== NOT EXECUTED
4000c714: 40 00 d9 00 call 40042b14 <__end+0x26d14> <== NOT EXECUTED
4000c718: 40 00 d9 00 call 40042b18 <__end+0x26d18> <== NOT EXECUTED
4000c71c: 40 00 d9 00 call 40042b1c <__end+0x26d1c> <== NOT EXECUTED
4000c720: 40 00 d8 cc call 40042a50 <__end+0x26c50> <== NOT EXECUTED
4000c724: 40 00 d8 b8 call 40042a04 <__end+0x26c04> <== NOT EXECUTED
4000c728: 40 00 d8 b8 call 40042a08 <__end+0x26c08> <== NOT EXECUTED
4000c72c: 40 00 d8 b8 call 40042a0c <__end+0x26c0c> <== NOT EXECUTED
4000c730: 40 00 d7 c8 call 40042650 <__end+0x26850> <== NOT EXECUTED
4000c734: 40 00 d7 b8 call 40042614 <__end+0x26814> <== NOT EXECUTED
4000c738: 40 00 d7 b8 call 40042618 <__end+0x26818> <== NOT EXECUTED
4000c73c: 40 00 d8 94 call 4004298c <__end+0x26b8c> <== NOT EXECUTED
4000c740: 40 00 d8 94 call 40042990 <__end+0x26b90> <== NOT EXECUTED
4000c744: 40 00 d8 94 call 40042994 <__end+0x26b94> <== NOT EXECUTED
4000c748: 40 00 d8 94 call 40042998 <__end+0x26b98> <== NOT EXECUTED
4000c74c: 40 00 d8 60 call 400428cc <__end+0x26acc> <== NOT EXECUTED
4000c750: 40 00 d8 4c call 40042880 <__end+0x26a80> <== NOT EXECUTED
4000c754: 40 00 d8 4c call 40042884 <__end+0x26a84> <== NOT EXECUTED
4000c758: 40 00 d8 4c call 40042888 <__end+0x26a88> <== NOT EXECUTED
4000c75c: 40 00 ed cc call 40047e8c <__end+0x2c08c> <== NOT EXECUTED
4000c760: 40 00 ed cc call 40047e90 <__end+0x2c090> <== NOT EXECUTED
4000c764: 40 00 ee f4 call 40048334 <__end+0x2c534> <== NOT EXECUTED
4000c768: 40 00 ef 1c call 400483d8 <__end+0x2c5d8> <== NOT EXECUTED
4000c76c: 40 00 ef 1c call 400483dc <__end+0x2c5dc> <== NOT EXECUTED
4000c770: 40 00 ef 1c call 400483e0 <__end+0x2c5e0> <== NOT EXECUTED
4000c774: 40 00 ed cc call 40047ea4 <__end+0x2c0a4> <== NOT EXECUTED
4000c778: 40 00 ee e4 call 40048308 <__end+0x2c508> <== NOT EXECUTED
4000c77c: 40 00 ee dc call 400482ec <__end+0x2c4ec> <== NOT EXECUTED
4000c780: 40 00 ef 24 call 40048410 <__end+0x2c610> <== NOT EXECUTED
4000c784: 40 00 ed cc call 40047eb4 <__end+0x2c0b4> <== NOT EXECUTED
4001b6d0 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
4001b6d0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001b6d4: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001b6d8: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1 ! 4001e3a4 <rtems_libio_number_iops>
4001b6dc: 80 a6 00 01 cmp %i0, %g1
4001b6e0: 1a 80 00 18 bcc 4001b740 <read+0x70>
4001b6e4: 03 10 00 7b sethi %hi(0x4001ec00), %g1
iop = rtems_libio_iop( fd );
4001b6e8: d0 00 61 30 ld [ %g1 + 0x130 ], %o0 ! 4001ed30 <rtems_libio_iops>
4001b6ec: 83 2e 20 03 sll %i0, 3, %g1
4001b6f0: b1 2e 20 06 sll %i0, 6, %i0
4001b6f4: b0 26 00 01 sub %i0, %g1, %i0
4001b6f8: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001b6fc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001b700: 80 88 61 00 btst 0x100, %g1
4001b704: 02 80 00 0f be 4001b740 <read+0x70>
4001b708: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001b70c: 02 80 00 13 be 4001b758 <read+0x88> <== NEVER TAKEN
4001b710: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
4001b714: 02 80 00 0f be 4001b750 <read+0x80>
4001b718: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001b71c: 80 88 60 02 btst 2, %g1
4001b720: 02 80 00 08 be 4001b740 <read+0x70>
4001b724: 92 10 00 19 mov %i1, %o1
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
4001b728: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001b72c: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001b730: 9f c0 40 00 call %g1
4001b734: 94 10 00 1a mov %i2, %o2
}
4001b738: 81 c7 e0 08 ret
4001b73c: 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 );
4001b740: 7f ff d0 00 call 4000f740 <__errno>
4001b744: b0 10 3f ff mov -1, %i0
4001b748: 82 10 20 09 mov 9, %g1
4001b74c: c2 22 00 00 st %g1, [ %o0 ]
4001b750: 81 c7 e0 08 ret
4001b754: 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 );
4001b758: 7f ff cf fa call 4000f740 <__errno> <== NOT EXECUTED
4001b75c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b760: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001b764: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b768: 81 c7 e0 08 ret <== NOT EXECUTED
4001b76c: 81 e8 00 00 restore <== NOT EXECUTED
40004674 <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)
{
40004674: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
40004678: 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)
{
4000467c: 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))
40004680: 80 a6 a0 00 cmp %i2, 0
40004684: 02 80 00 16 be 400046dc <read_extended_partition+0x68> <== NEVER TAKEN
40004688: b0 10 20 19 mov 0x19, %i0
4000468c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40004690: 80 a0 60 00 cmp %g1, 0
40004694: 02 80 00 12 be 400046dc <read_extended_partition+0x68> <== NEVER TAKEN
40004698: 90 10 00 1d mov %i5, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
4000469c: e0 06 a0 04 ld [ %i2 + 4 ], %l0
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
400046a0: b9 2c 20 09 sll %l0, 9, %i4
new_off = lseek(fd, off, SEEK_SET);
400046a4: 92 10 20 00 clr %o1
400046a8: 94 10 00 1c mov %i4, %o2
400046ac: 40 00 04 57 call 40005808 <lseek>
400046b0: 96 10 20 00 clr %o3
if (new_off != off) {
400046b4: 80 a2 20 00 cmp %o0, 0
400046b8: 02 80 00 0b be 400046e4 <read_extended_partition+0x70> <== ALWAYS TAKEN
400046bc: 80 a7 00 09 cmp %i4, %o1
return RTEMS_IO_ERROR;
400046c0: 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)
400046c4: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
400046c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400046cc: 02 80 00 41 be 400047d0 <read_extended_partition+0x15c> <== NOT EXECUTED
400046d0: 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);
400046d4: 40 00 03 29 call 40005378 <free> <== NOT EXECUTED
400046d8: 01 00 00 00 nop <== NOT EXECUTED
400046dc: 81 c7 e0 08 ret <== NOT EXECUTED
400046e0: 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) {
400046e4: 12 bf ff f8 bne 400046c4 <read_extended_partition+0x50> <== NEVER TAKEN
400046e8: b0 10 20 1b mov 0x1b, %i0
400046ec: 90 10 00 1d mov %i5, %o0
400046f0: 92 10 00 10 mov %l0, %o1
400046f4: 7f ff ff 7c call 400044e4 <get_sector.part.0>
400046f8: 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)
400046fc: b0 92 20 00 orcc %o0, 0, %i0
40004700: 12 bf ff f1 bne 400046c4 <read_extended_partition+0x50> <== NEVER TAKEN
40004704: 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) &&
40004708: c2 0a 22 02 ldub [ %o0 + 0x202 ], %g1
4000470c: 80 a0 60 55 cmp %g1, 0x55
40004710: 22 80 00 06 be,a 40004728 <read_extended_partition+0xb4> <== ALWAYS TAKEN
40004714: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
return rc;
}
if (!msdos_signature_check(sector))
{
free(sector);
40004718: 40 00 03 18 call 40005378 <free> <== NOT EXECUTED
4000471c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
40004720: 81 c7 e0 08 ret <== NOT EXECUTED
40004724: 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) &&
40004728: 80 a0 60 aa cmp %g1, 0xaa
4000472c: 12 bf ff fb bne 40004718 <read_extended_partition+0xa4> <== NEVER TAKEN
40004730: b6 02 21 d2 add %o0, 0x1d2, %i3
40004734: 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)
40004738: a2 06 a0 10 add %i2, 0x10, %l1
4000473c: 90 06 ff f0 add %i3, -16, %o0
40004740: 7f ff ff 80 call 40004540 <data_to_part_desc.part.1>
40004744: 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)
40004748: b0 92 20 00 orcc %o0, 0, %i0
4000474c: 12 80 00 1f bne 400047c8 <read_extended_partition+0x154> <== NEVER TAKEN
40004750: d4 07 bf fc ld [ %fp + -4 ], %o2
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
40004754: 80 a2 a0 00 cmp %o2, 0
40004758: 22 80 00 19 be,a 400047bc <read_extended_partition+0x148>
4000475c: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
40004760: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
40004764: 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));
40004768: 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;
4000476c: 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))
40004770: 84 08 a0 7f and %g2, 0x7f, %g2
40004774: 80 a0 a0 05 cmp %g2, 5
40004778: 02 80 00 18 be 400047d8 <read_extended_partition+0x164>
4000477c: 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;
40004780: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
40004784: de 02 a0 04 ld [ %o2 + 4 ], %o7
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40004788: 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;
4000478c: 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;
40004790: 86 00 e0 0a add %g3, 0xa, %g3
new_part_desc->log_id = ++disk_desc->last_log_id;
40004794: 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;
40004798: 87 28 e0 02 sll %g3, 2, %g3
4000479c: d4 20 40 03 st %o2, [ %g1 + %g3 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
400047a0: c4 2a a0 02 stb %g2, [ %o2 + 2 ]
new_part_desc->start += here;
400047a4: 82 04 00 0f add %l0, %o7, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
400047a8: 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;
400047ac: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
400047b0: 82 00 80 01 add %g2, %g1, %g1
400047b4: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
400047b8: 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++)
400047bc: 80 a7 00 11 cmp %i4, %l1
400047c0: 12 bf ff df bne 4000473c <read_extended_partition+0xc8>
400047c4: 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);
400047c8: 40 00 02 ec call 40005378 <free>
400047cc: d0 07 bf f8 ld [ %fp + -8 ], %o0
400047d0: 81 c7 e0 08 ret
400047d4: 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;
400047d8: 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;
400047dc: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
400047e0: 82 00 40 19 add %g1, %i1, %g1
read_extended_partition(fd, start, new_part_desc);
400047e4: 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;
400047e8: c2 22 a0 04 st %g1, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
400047ec: 7f ff ff a2 call 40004674 <read_extended_partition>
400047f0: 92 10 00 19 mov %i1, %o1
400047f4: 10 bf ff f2 b 400047bc <read_extended_partition+0x148>
400047f8: b8 07 20 04 add %i4, 4, %i4
400048ec <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
400048ec: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
400048f0: 03 10 00 5d sethi %hi(0x40017400), %g1
400048f4: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 400177d4 <rtems_libio_number_iops>
400048f8: 80 a6 00 01 cmp %i0, %g1
400048fc: 1a 80 00 45 bcc 40004a10 <readv+0x124>
40004900: 03 10 00 60 sethi %hi(0x40018000), %g1
iop = rtems_libio_iop( fd );
40004904: f6 00 61 2c ld [ %g1 + 0x12c ], %i3 ! 4001812c <rtems_libio_iops>
40004908: 83 2e 20 03 sll %i0, 3, %g1
4000490c: b1 2e 20 06 sll %i0, 6, %i0
40004910: b0 26 00 01 sub %i0, %g1, %i0
40004914: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
40004918: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000491c: 80 88 61 00 btst 0x100, %g1
40004920: 02 80 00 3c be 40004a10 <readv+0x124>
40004924: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40004928: 02 80 00 3a be 40004a10 <readv+0x124> <== NEVER TAKEN
4000492c: 80 a6 60 00 cmp %i1, 0
/*
* Argument validation on IO vector
*/
if ( !iov )
40004930: 02 80 00 32 be 400049f8 <readv+0x10c>
40004934: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
40004938: 04 80 00 30 ble 400049f8 <readv+0x10c>
4000493c: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
40004940: 14 80 00 2e bg 400049f8 <readv+0x10c> <== NEVER TAKEN
40004944: b5 2e a0 03 sll %i2, 3, %i2
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
40004948: 82 10 20 00 clr %g1
4000494c: ba 10 20 01 mov 1, %i5
40004950: 10 80 00 03 b 4000495c <readv+0x70>
40004954: 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;
40004958: 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 )
4000495c: c6 06 40 01 ld [ %i1 + %g1 ], %g3
40004960: 80 a0 e0 00 cmp %g3, 0
40004964: 02 80 00 25 be 400049f8 <readv+0x10c>
40004968: 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;
4000496c: c6 01 20 04 ld [ %g4 + 4 ], %g3
40004970: 88 00 c0 02 add %g3, %g2, %g4
if ( total < old )
40004974: 80 a1 00 02 cmp %g4, %g2
40004978: 06 80 00 20 bl 400049f8 <readv+0x10c>
4000497c: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
40004980: 80 a0 00 03 cmp %g0, %g3
40004984: 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++ ) {
40004988: 80 a0 40 1a cmp %g1, %i2
4000498c: 12 bf ff f3 bne 40004958 <readv+0x6c>
40004990: 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 ) {
40004994: 80 8f 60 ff btst 0xff, %i5
40004998: 12 80 00 16 bne 400049f0 <readv+0x104>
4000499c: b0 10 20 00 clr %i0
400049a0: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
400049a4: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
400049a8: 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)(
400049ac: d2 06 40 1d ld [ %i1 + %i5 ], %o1
400049b0: c2 00 60 08 ld [ %g1 + 8 ], %g1
400049b4: d4 07 20 04 ld [ %i4 + 4 ], %o2
400049b8: 9f c0 40 00 call %g1
400049bc: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
400049c0: 80 a2 20 00 cmp %o0, 0
400049c4: 26 80 00 0b bl,a 400049f0 <readv+0x104> <== NEVER TAKEN
400049c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
400049cc: 32 80 00 02 bne,a 400049d4 <readv+0xe8> <== ALWAYS TAKEN
400049d0: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
400049d4: c2 07 20 04 ld [ %i4 + 4 ], %g1
400049d8: 80 a2 00 01 cmp %o0, %g1
400049dc: 12 80 00 05 bne 400049f0 <readv+0x104> <== NEVER TAKEN
400049e0: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
400049e4: 80 a6 80 1d cmp %i2, %i5
400049e8: 32 bf ff f0 bne,a 400049a8 <readv+0xbc>
400049ec: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
400049f0: 81 c7 e0 08 ret
400049f4: 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 );
400049f8: 40 00 2d a3 call 40010084 <__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
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 );
40004a10: 40 00 2d 9d call 40010084 <__errno>
40004a14: b0 10 3f ff mov -1, %i0
40004a18: 82 10 20 09 mov 9, %g1
40004a1c: c2 22 00 00 st %g1, [ %o0 ]
40004a20: 81 c7 e0 08 ret
40004a24: 81 e8 00 00 restore
4001b7cc <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
4001b7cc: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
4001b7d0: 3b 10 00 7b sethi %hi(0x4001ec00), %i5
4001b7d4: ba 17 61 40 or %i5, 0x140, %i5 ! 4001ed40 <rtems_malloc_statistics>
4001b7d8: 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())) {
4001b7dc: 03 10 00 7c sethi %hi(0x4001f000), %g1
4001b7e0: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 4001f3c8 <_System_state_Current>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
4001b7e4: 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())) {
4001b7e8: 80 a0 60 03 cmp %g1, 3
4001b7ec: 02 80 00 2a be 4001b894 <realloc+0xc8>
4001b7f0: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
}
/*
* Continue with realloc().
*/
if ( !ptr )
4001b7f4: 80 a6 20 00 cmp %i0, 0
4001b7f8: 02 80 00 46 be 4001b910 <realloc+0x144>
4001b7fc: 80 a6 60 00 cmp %i1, 0
return malloc( size );
if ( !size ) {
4001b800: 02 80 00 39 be 4001b8e4 <realloc+0x118> <== NEVER TAKEN
4001b804: 39 10 00 78 sethi %hi(0x4001e000), %i4
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
4001b808: d0 07 23 60 ld [ %i4 + 0x360 ], %o0 ! 4001e360 <RTEMS_Malloc_Heap>
4001b80c: 92 10 00 18 mov %i0, %o1
4001b810: 40 00 01 d6 call 4001bf68 <_Protected_heap_Get_block_size>
4001b814: 94 07 bf fc add %fp, -4, %o2
4001b818: 80 8a 20 ff btst 0xff, %o0
4001b81c: 02 80 00 37 be 4001b8f8 <realloc+0x12c>
4001b820: d0 07 23 60 ld [ %i4 + 0x360 ], %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
4001b824: 92 10 00 18 mov %i0, %o1
4001b828: 40 00 01 de call 4001bfa0 <_Protected_heap_Resize_block>
4001b82c: 94 10 00 19 mov %i1, %o2
4001b830: 80 8a 20 ff btst 0xff, %o0
4001b834: 02 80 00 04 be 4001b844 <realloc+0x78>
4001b838: 01 00 00 00 nop
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
4001b83c: 81 c7 e0 08 ret
4001b840: 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 );
4001b844: 7f ff 9e d3 call 40003390 <malloc>
4001b848: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001b84c: 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 );
4001b850: b8 10 00 08 mov %o0, %i4
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001b854: 82 00 7f ff add %g1, -1, %g1
if ( !new_area ) {
4001b858: 80 a2 20 00 cmp %o0, 0
4001b85c: 02 80 00 17 be 4001b8b8 <realloc+0xec>
4001b860: c2 27 60 04 st %g1, [ %i5 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
4001b864: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b868: 80 a6 40 01 cmp %i1, %g1
4001b86c: 18 80 00 15 bgu 4001b8c0 <realloc+0xf4> <== ALWAYS TAKEN
4001b870: 94 10 00 19 mov %i1, %o2
4001b874: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001b878: 7f ff d2 03 call 40010084 <memcpy> <== NOT EXECUTED
4001b87c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free( ptr );
4001b880: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b884: 7f ff 9d e9 call 40003028 <free> <== NOT EXECUTED
4001b888: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4001b88c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b890: 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 )
4001b894: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4001b898: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 4001eec0 <_Thread_Dispatch_disable_level>
4001b89c: 80 a0 60 00 cmp %g1, 0
4001b8a0: 12 80 00 06 bne 4001b8b8 <realloc+0xec> <== NEVER TAKEN
4001b8a4: 03 10 00 7c sethi %hi(0x4001f000), %g1
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
4001b8a8: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1 ! 4001f3d8 <_Per_CPU_Information+0x8>
4001b8ac: 80 a0 60 00 cmp %g1, 0
4001b8b0: 02 bf ff d2 be 4001b7f8 <realloc+0x2c> <== ALWAYS TAKEN
4001b8b4: 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;
4001b8b8: 81 c7 e0 08 ret
4001b8bc: 91 e8 20 00 restore %g0, 0, %o0
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
4001b8c0: 92 10 00 18 mov %i0, %o1
4001b8c4: 94 10 00 01 mov %g1, %o2
4001b8c8: 7f ff d1 ef call 40010084 <memcpy>
4001b8cc: 90 10 00 1c mov %i4, %o0
free( ptr );
4001b8d0: 90 10 00 18 mov %i0, %o0
4001b8d4: 7f ff 9d d5 call 40003028 <free>
4001b8d8: b0 10 00 1c mov %i4, %i0
4001b8dc: 81 c7 e0 08 ret
4001b8e0: 81 e8 00 00 restore
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
4001b8e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b8e8: 7f ff 9d d0 call 40003028 <free> <== NOT EXECUTED
4001b8ec: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001b8f0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b8f4: 81 e8 00 00 restore <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
4001b8f8: 7f ff cf 92 call 4000f740 <__errno>
4001b8fc: b0 10 20 00 clr %i0
4001b900: 82 10 20 16 mov 0x16, %g1
4001b904: c2 22 00 00 st %g1, [ %o0 ]
4001b908: 81 c7 e0 08 ret
4001b90c: 81 e8 00 00 restore
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
4001b910: 7f ff 9e a0 call 40003390 <malloc>
4001b914: 91 e8 00 19 restore %g0, %i1, %o0
400078f4 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
400078f4: 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);
400078f8: 39 10 00 63 sethi %hi(0x40018c00), %i4
400078fc: 40 00 02 7b call 400082e8 <pthread_mutex_lock>
40007900: 90 17 23 f4 or %i4, 0x3f4, %o0 ! 40018ff4 <aio_request_queue>
if (result != 0) {
40007904: b6 92 20 00 orcc %o0, 0, %i3
40007908: 12 80 00 31 bne 400079cc <rtems_aio_enqueue+0xd8> <== NEVER TAKEN
4000790c: 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);
40007910: 40 00 04 b6 call 40008be8 <pthread_self>
40007914: b2 17 23 f4 or %i4, 0x3f4, %i1
40007918: 92 07 bf e0 add %fp, -32, %o1
4000791c: 40 00 03 a8 call 400087bc <pthread_getschedparam>
40007920: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
40007924: 40 00 04 b1 call 40008be8 <pthread_self>
40007928: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
4000792c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
req->policy = policy;
40007930: 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;
40007934: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
req->policy = policy;
40007938: 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;
4000793c: 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 ();
40007940: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40007944: 84 20 c0 02 sub %g3, %g2, %g2
40007948: 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) &&
4000794c: 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;
40007950: 86 10 20 77 mov 0x77, %g3
req->aiocbp->return_value = 0;
40007954: 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;
40007958: c6 20 60 34 st %g3, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
4000795c: 80 a0 a0 00 cmp %g2, 0
40007960: 12 80 00 06 bne 40007978 <rtems_aio_enqueue+0x84> <== NEVER TAKEN
40007964: d2 00 40 00 ld [ %g1 ], %o1
40007968: c4 06 60 64 ld [ %i1 + 0x64 ], %g2
4000796c: 80 a0 a0 04 cmp %g2, 4
40007970: 24 80 00 1b ble,a 400079dc <rtems_aio_enqueue+0xe8>
40007974: 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,
40007978: 94 10 20 00 clr %o2
4000797c: 11 10 00 64 sethi %hi(0x40019000), %o0
40007980: 7f ff ff 78 call 40007760 <rtems_aio_search_fd>
40007984: 90 12 20 3c or %o0, 0x3c, %o0 ! 4001903c <aio_request_queue+0x48>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
40007988: b4 92 20 00 orcc %o0, 0, %i2
4000798c: 22 80 00 31 be,a 40007a50 <rtems_aio_enqueue+0x15c>
40007990: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
pthread_mutex_lock (&r_chain->mutex);
40007994: b2 06 a0 1c add %i2, 0x1c, %i1
40007998: 40 00 02 54 call 400082e8 <pthread_mutex_lock>
4000799c: 90 10 00 19 mov %i1, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
400079a0: 90 06 a0 08 add %i2, 8, %o0
400079a4: 7f ff ff 12 call 400075ec <rtems_aio_insert_prio>
400079a8: 92 10 00 18 mov %i0, %o1
pthread_cond_signal (&r_chain->cond);
400079ac: 40 00 01 2c call 40007e5c <pthread_cond_signal>
400079b0: 90 06 a0 20 add %i2, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
400079b4: 40 00 02 6d call 40008368 <pthread_mutex_unlock>
400079b8: 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);
400079bc: 40 00 02 6b call 40008368 <pthread_mutex_unlock>
400079c0: 90 17 23 f4 or %i4, 0x3f4, %o0
return 0;
}
400079c4: 81 c7 e0 08 ret
400079c8: 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);
400079cc: 7f ff ee 4c call 400032fc <free> <== NOT EXECUTED
400079d0: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
400079d4: 81 c7 e0 08 ret <== NOT EXECUTED
400079d8: 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);
400079dc: 7f ff ff 61 call 40007760 <rtems_aio_search_fd>
400079e0: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
400079e4: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
400079e8: 80 a0 60 01 cmp %g1, 1
400079ec: 12 bf ff ea bne 40007994 <rtems_aio_enqueue+0xa0>
400079f0: 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);
400079f4: 90 02 20 08 add %o0, 8, %o0
400079f8: 40 00 09 44 call 40009f08 <_Chain_Insert>
400079fc: 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);
40007a00: 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;
40007a04: c0 26 a0 18 clr [ %i2 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40007a08: 40 00 01 df call 40008184 <pthread_mutex_init>
40007a0c: 90 06 a0 1c add %i2, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
40007a10: 92 10 20 00 clr %o1
40007a14: 40 00 00 e3 call 40007da0 <pthread_cond_init>
40007a18: 90 06 a0 20 add %i2, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
40007a1c: 90 07 bf dc add %fp, -36, %o0
40007a20: 92 06 60 08 add %i1, 8, %o1
40007a24: 96 10 00 1a mov %i2, %o3
40007a28: 15 10 00 1c sethi %hi(0x40007000), %o2
40007a2c: 40 00 02 c4 call 4000853c <pthread_create>
40007a30: 94 12 a3 40 or %o2, 0x340, %o2 ! 40007340 <rtems_aio_handle>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
40007a34: 82 92 20 00 orcc %o0, 0, %g1
40007a38: 12 80 00 25 bne 40007acc <rtems_aio_enqueue+0x1d8> <== NEVER TAKEN
40007a3c: 90 10 00 19 mov %i1, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
40007a40: c2 06 60 64 ld [ %i1 + 0x64 ], %g1
40007a44: 82 00 60 01 inc %g1
40007a48: 10 bf ff dd b 400079bc <rtems_aio_enqueue+0xc8>
40007a4c: 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);
40007a50: 11 10 00 64 sethi %hi(0x40019000), %o0
40007a54: d2 00 40 00 ld [ %g1 ], %o1
40007a58: 90 12 20 48 or %o0, 0x48, %o0
40007a5c: 7f ff ff 41 call 40007760 <rtems_aio_search_fd>
40007a60: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
40007a64: 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);
40007a68: b4 10 00 08 mov %o0, %i2
40007a6c: 92 10 00 18 mov %i0, %o1
if (r_chain->new_fd == 1) {
40007a70: 80 a0 60 01 cmp %g1, 1
40007a74: 02 80 00 0b be 40007aa0 <rtems_aio_enqueue+0x1ac>
40007a78: 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);
40007a7c: 7f ff fe dc call 400075ec <rtems_aio_insert_prio>
40007a80: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
40007a84: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
40007a88: 80 a0 60 00 cmp %g1, 0
40007a8c: 04 bf ff cc ble 400079bc <rtems_aio_enqueue+0xc8> <== ALWAYS TAKEN
40007a90: 01 00 00 00 nop
pthread_cond_signal (&aio_request_queue.new_req);
40007a94: 40 00 00 f2 call 40007e5c <pthread_cond_signal> <== NOT EXECUTED
40007a98: 90 06 60 04 add %i1, 4, %o0 <== NOT EXECUTED
40007a9c: 30 bf ff c8 b,a 400079bc <rtems_aio_enqueue+0xc8> <== NOT EXECUTED
40007aa0: 40 00 09 1a call 40009f08 <_Chain_Insert>
40007aa4: 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);
40007aa8: 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;
40007aac: c0 26 a0 18 clr [ %i2 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40007ab0: 40 00 01 b5 call 40008184 <pthread_mutex_init>
40007ab4: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
40007ab8: 90 06 a0 20 add %i2, 0x20, %o0
40007abc: 40 00 00 b9 call 40007da0 <pthread_cond_init>
40007ac0: 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)
40007ac4: 10 bf ff f1 b 40007a88 <rtems_aio_enqueue+0x194>
40007ac8: 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);
40007acc: 40 00 02 27 call 40008368 <pthread_mutex_unlock> <== NOT EXECUTED
40007ad0: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
40007ad4: 30 bf ff bc b,a 400079c4 <rtems_aio_enqueue+0xd0> <== NOT EXECUTED
40007340 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
40007340: 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);
40007344: 35 10 00 63 sethi %hi(0x40018c00), %i2
40007348: b6 06 20 1c add %i0, 0x1c, %i3
4000734c: b4 16 a3 f4 or %i2, 0x3f4, %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,
40007350: a0 10 00 1a mov %i2, %l0
40007354: 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)) {
40007358: 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 &&
4000735c: 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);
40007360: 40 00 03 e2 call 400082e8 <pthread_mutex_lock>
40007364: 90 10 00 1b mov %i3, %o0
if (result != 0)
40007368: 80 a2 20 00 cmp %o0, 0
4000736c: 12 80 00 2b bne 40007418 <rtems_aio_handle+0xd8> <== NEVER TAKEN
40007370: 01 00 00 00 nop
40007374: 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 );
40007378: 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)) {
4000737c: 80 a7 40 01 cmp %i5, %g1
40007380: 02 80 00 41 be 40007484 <rtems_aio_handle+0x144>
40007384: 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);
40007388: 40 00 06 18 call 40008be8 <pthread_self>
4000738c: 01 00 00 00 nop
40007390: 92 07 bf d8 add %fp, -40, %o1
40007394: 40 00 05 0a call 400087bc <pthread_getschedparam>
40007398: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
4000739c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
400073a0: 40 00 06 12 call 40008be8 <pthread_self>
400073a4: c2 27 bf e4 st %g1, [ %fp + -28 ]
400073a8: d2 07 60 08 ld [ %i5 + 8 ], %o1
400073ac: 40 00 06 13 call 40008bf8 <pthread_setschedparam>
400073b0: 94 07 bf e4 add %fp, -28, %o2
400073b4: 40 00 0a bc call 40009ea4 <_Chain_Extract>
400073b8: 90 10 00 1d mov %i5, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
400073bc: 40 00 03 eb call 40008368 <pthread_mutex_unlock>
400073c0: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
400073c4: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
400073c8: c2 07 20 30 ld [ %i4 + 0x30 ], %g1
400073cc: 80 a0 60 02 cmp %g1, 2
400073d0: 22 80 00 25 be,a 40007464 <rtems_aio_handle+0x124>
400073d4: c4 1f 20 08 ldd [ %i4 + 8 ], %g2
400073d8: 80 a0 60 03 cmp %g1, 3
400073dc: 02 80 00 1e be 40007454 <rtems_aio_handle+0x114> <== NEVER TAKEN
400073e0: 01 00 00 00 nop
400073e4: 80 a0 60 01 cmp %g1, 1
400073e8: 22 80 00 0e be,a 40007420 <rtems_aio_handle+0xe0> <== ALWAYS TAKEN
400073ec: c4 1f 20 08 ldd [ %i4 + 8 ], %g2
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
400073f0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
400073f4: 40 00 29 13 call 40011840 <__errno> <== NOT EXECUTED
400073f8: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
400073fc: 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);
40007400: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40007404: 40 00 03 b9 call 400082e8 <pthread_mutex_lock> <== NOT EXECUTED
40007408: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
if (result != 0)
4000740c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40007410: 22 bf ff da be,a 40007378 <rtems_aio_handle+0x38> <== NOT EXECUTED
40007414: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
40007418: 81 c7 e0 08 ret
4000741c: 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,
40007420: d0 07 00 00 ld [ %i4 ], %o0
40007424: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
40007428: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
4000742c: 96 10 00 02 mov %g2, %o3
40007430: 40 00 2b f0 call 400123f0 <pread>
40007434: 98 10 00 03 mov %g3, %o4
break;
default:
result = -1;
}
if (result == -1) {
40007438: 80 a2 3f ff cmp %o0, -1
4000743c: 22 bf ff ed be,a 400073f0 <rtems_aio_handle+0xb0> <== NEVER TAKEN
40007440: 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;
40007444: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40007448: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
4000744c: 10 bf ff c5 b 40007360 <rtems_aio_handle+0x20>
40007450: 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);
40007454: 40 00 1b 79 call 4000e238 <fsync> <== NOT EXECUTED
40007458: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
break;
4000745c: 10 bf ff f8 b 4000743c <rtems_aio_handle+0xfc> <== NOT EXECUTED
40007460: 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,
40007464: d0 07 00 00 ld [ %i4 ], %o0
40007468: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
4000746c: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
40007470: 96 10 00 02 mov %g2, %o3
40007474: 40 00 2c 1d call 400124e8 <pwrite>
40007478: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
4000747c: 10 bf ff f0 b 4000743c <rtems_aio_handle+0xfc>
40007480: 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);
40007484: 40 00 03 b9 call 40008368 <pthread_mutex_unlock>
40007488: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
4000748c: 40 00 03 97 call 400082e8 <pthread_mutex_lock>
40007490: 90 10 00 1a mov %i2, %o0
if (rtems_chain_is_empty (chain))
40007494: c2 06 20 08 ld [ %i0 + 8 ], %g1
40007498: 80 a7 40 01 cmp %i5, %g1
4000749c: 02 80 00 05 be 400074b0 <rtems_aio_handle+0x170> <== ALWAYS TAKEN
400074a0: 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);
400074a4: 40 00 03 b1 call 40008368 <pthread_mutex_unlock>
400074a8: 90 10 00 1a mov %i2, %o0
400074ac: 30 bf ff ad b,a 40007360 <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);
400074b0: 40 00 01 d3 call 40007bfc <clock_gettime>
400074b4: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
400074b8: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
400074bc: 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;
400074c0: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
400074c4: 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;
400074c8: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
400074cc: 90 10 00 1d mov %i5, %o0
400074d0: 92 10 00 10 mov %l0, %o1
400074d4: 40 00 02 7e call 40007ecc <pthread_cond_timedwait>
400074d8: 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) {
400074dc: 80 a2 20 74 cmp %o0, 0x74
400074e0: 12 bf ff f1 bne 400074a4 <rtems_aio_handle+0x164> <== NEVER TAKEN
400074e4: 01 00 00 00 nop
400074e8: 40 00 0a 6f call 40009ea4 <_Chain_Extract>
400074ec: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
400074f0: 40 00 02 d2 call 40008038 <pthread_mutex_destroy>
400074f4: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
400074f8: 40 00 01 f4 call 40007cc8 <pthread_cond_destroy>
400074fc: 90 10 00 1d mov %i5, %o0
free (r_chain);
40007500: 7f ff ef 7f call 400032fc <free>
40007504: 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;
40007508: 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)) {
4000750c: 80 a6 00 12 cmp %i0, %l2
40007510: 22 80 00 1d be,a 40007584 <rtems_aio_handle+0x244>
40007514: 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;
40007518: c4 04 60 68 ld [ %l1 + 0x68 ], %g2
++aio_request_queue.active_threads;
4000751c: 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;
40007520: 84 00 bf ff add %g2, -1, %g2
++aio_request_queue.active_threads;
40007524: 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;
40007528: c4 24 60 68 st %g2, [ %l1 + 0x68 ]
++aio_request_queue.active_threads;
4000752c: c2 24 60 64 st %g1, [ %l1 + 0x64 ]
40007530: 40 00 0a 5d call 40009ea4 <_Chain_Extract>
40007534: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40007538: 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 &&
4000753c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
40007540: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40007544: 80 a0 c0 02 cmp %g3, %g2
40007548: 14 80 00 08 bg 40007568 <rtems_aio_handle+0x228> <== ALWAYS TAKEN
4000754c: 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 );
40007550: 10 80 00 09 b 40007574 <rtems_aio_handle+0x234> <== NOT EXECUTED
40007554: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
40007558: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000755c: 80 a0 80 03 cmp %g2, %g3
40007560: 16 80 00 04 bge 40007570 <rtems_aio_handle+0x230>
40007564: 80 a0 40 19 cmp %g1, %i1
40007568: 32 bf ff fc bne,a 40007558 <rtems_aio_handle+0x218> <== ALWAYS TAKEN
4000756c: c2 00 40 00 ld [ %g1 ], %g1
40007570: d0 00 60 04 ld [ %g1 + 4 ], %o0
40007574: 92 10 00 18 mov %i0, %o1
40007578: 40 00 0a 64 call 40009f08 <_Chain_Insert>
4000757c: b6 06 20 1c add %i0, 0x1c, %i3
40007580: 30 bf ff c9 b,a 400074a4 <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;
40007584: 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;
40007588: 84 00 a0 01 inc %g2
--aio_request_queue.active_threads;
4000758c: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
40007590: 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;
40007594: c4 26 a0 68 st %g2, [ %i2 + 0x68 ]
--aio_request_queue.active_threads;
40007598: c2 26 a0 64 st %g1, [ %i2 + 0x64 ]
clock_gettime (CLOCK_REALTIME, &timeout);
4000759c: 40 00 01 98 call 40007bfc <clock_gettime>
400075a0: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
400075a4: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
400075a8: 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;
400075ac: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
400075b0: 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;
400075b4: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
400075b8: 92 10 00 1a mov %i2, %o1
400075bc: 40 00 02 44 call 40007ecc <pthread_cond_timedwait>
400075c0: 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) {
400075c4: 80 a2 20 74 cmp %o0, 0x74
400075c8: 22 80 00 04 be,a 400075d8 <rtems_aio_handle+0x298> <== ALWAYS TAKEN
400075cc: c2 06 a0 68 ld [ %i2 + 0x68 ], %g1
400075d0: 10 bf ff d2 b 40007518 <rtems_aio_handle+0x1d8> <== NOT EXECUTED
400075d4: 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);
400075d8: 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;
400075dc: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
400075e0: 40 00 03 62 call 40008368 <pthread_mutex_unlock>
400075e4: c2 26 a0 68 st %g1, [ %i2 + 0x68 ]
400075e8: 30 bf ff 8c b,a 40007418 <rtems_aio_handle+0xd8>
40007658 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
40007658: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
4000765c: 3b 10 00 63 sethi %hi(0x40018c00), %i5
40007660: 40 00 03 9c call 400084d0 <pthread_attr_init>
40007664: 90 17 63 fc or %i5, 0x3fc, %o0 ! 40018ffc <aio_request_queue+0x8>
if (result != 0)
40007668: b0 92 20 00 orcc %o0, 0, %i0
4000766c: 12 80 00 23 bne 400076f8 <rtems_aio_init+0xa0> <== NEVER TAKEN
40007670: 90 17 63 fc or %i5, 0x3fc, %o0
return result;
result =
40007674: 40 00 03 a3 call 40008500 <pthread_attr_setdetachstate>
40007678: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
4000767c: 80 a2 20 00 cmp %o0, 0
40007680: 12 80 00 20 bne 40007700 <rtems_aio_init+0xa8> <== NEVER TAKEN
40007684: 39 10 00 63 sethi %hi(0x40018c00), %i4
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
40007688: 92 10 20 00 clr %o1
4000768c: 40 00 02 be call 40008184 <pthread_mutex_init>
40007690: 90 17 23 f4 or %i4, 0x3f4, %o0
if (result != 0)
40007694: 80 a2 20 00 cmp %o0, 0
40007698: 12 80 00 23 bne 40007724 <rtems_aio_init+0xcc> <== NEVER TAKEN
4000769c: 92 10 20 00 clr %o1
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
400076a0: 11 10 00 63 sethi %hi(0x40018c00), %o0
400076a4: 40 00 01 bf call 40007da0 <pthread_cond_init>
400076a8: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 40018ff8 <aio_request_queue+0x4>
if (result != 0) {
400076ac: b0 92 20 00 orcc %o0, 0, %i0
400076b0: 12 80 00 26 bne 40007748 <rtems_aio_init+0xf0> <== NEVER TAKEN
400076b4: 01 00 00 00 nop
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400076b8: 82 17 23 f4 or %i4, 0x3f4, %g1
head->previous = NULL;
tail->previous = head;
400076bc: 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;
400076c0: ba 00 60 4c add %g1, 0x4c, %i5
head->previous = NULL;
tail->previous = head;
400076c4: 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;
400076c8: 86 00 60 58 add %g1, 0x58, %g3
head->previous = NULL;
tail->previous = head;
400076cc: 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;
400076d0: fa 20 60 48 st %i5, [ %g1 + 0x48 ]
head->previous = NULL;
400076d4: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
400076d8: 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;
400076dc: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
head->previous = NULL;
400076e0: 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;
400076e4: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
400076e8: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
400076ec: 05 00 00 2c sethi %hi(0xb000), %g2
400076f0: 84 10 a0 0b or %g2, 0xb, %g2 ! b00b <PROM_START+0xb00b>
400076f4: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
400076f8: 81 c7 e0 08 ret
400076fc: 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);
40007700: 40 00 03 68 call 400084a0 <pthread_attr_destroy> <== NOT EXECUTED
40007704: 90 17 63 fc or %i5, 0x3fc, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
40007708: 39 10 00 63 sethi %hi(0x40018c00), %i4 <== NOT EXECUTED
4000770c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40007710: 40 00 02 9d call 40008184 <pthread_mutex_init> <== NOT EXECUTED
40007714: 90 17 23 f4 or %i4, 0x3f4, %o0 <== NOT EXECUTED
if (result != 0)
40007718: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000771c: 02 bf ff e1 be 400076a0 <rtems_aio_init+0x48> <== NOT EXECUTED
40007720: 92 10 20 00 clr %o1 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
40007724: 40 00 03 5f call 400084a0 <pthread_attr_destroy> <== NOT EXECUTED
40007728: 90 17 63 fc or %i5, 0x3fc, %o0 <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4000772c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40007730: 11 10 00 63 sethi %hi(0x40018c00), %o0 <== NOT EXECUTED
40007734: 40 00 01 9b call 40007da0 <pthread_cond_init> <== NOT EXECUTED
40007738: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 40018ff8 <aio_request_queue+0x4><== NOT EXECUTED
if (result != 0) {
4000773c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40007740: 22 bf ff df be,a 400076bc <rtems_aio_init+0x64> <== NOT EXECUTED
40007744: 82 17 23 f4 or %i4, 0x3f4, %g1 <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
40007748: 40 00 02 3c call 40008038 <pthread_mutex_destroy> <== NOT EXECUTED
4000774c: 90 17 23 f4 or %i4, 0x3f4, %o0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
40007750: 40 00 03 54 call 400084a0 <pthread_attr_destroy> <== NOT EXECUTED
40007754: 90 17 63 fc or %i5, 0x3fc, %o0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40007758: 10 bf ff d9 b 400076bc <rtems_aio_init+0x64> <== NOT EXECUTED
4000775c: 82 17 23 f4 or %i4, 0x3f4, %g1 <== NOT EXECUTED
400075ec <rtems_aio_insert_prio>:
400075ec: 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 );
400075f0: 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)) {
400075f4: 80 a0 40 04 cmp %g1, %g4
400075f8: 02 80 00 15 be 4000764c <rtems_aio_insert_prio+0x60> <== NEVER TAKEN
400075fc: 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 &&
40007600: 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;
40007604: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
while (req->aiocbp->aio_reqprio > prio &&
40007608: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
4000760c: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2
40007610: 80 a0 80 03 cmp %g2, %g3
40007614: 26 80 00 07 bl,a 40007630 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
40007618: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000761c: 10 80 00 0b b 40007648 <rtems_aio_insert_prio+0x5c>
40007620: d0 00 60 04 ld [ %g1 + 4 ], %o0
40007624: 22 80 00 09 be,a 40007648 <rtems_aio_insert_prio+0x5c> <== NOT EXECUTED
40007628: 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;
4000762c: 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;
40007630: 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 &&
40007634: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2 <== NOT EXECUTED
40007638: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000763c: 06 bf ff fa bl 40007624 <rtems_aio_insert_prio+0x38> <== NOT EXECUTED
40007640: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED
40007644: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
40007648: 92 10 00 0d mov %o5, %o1
4000764c: 82 13 c0 00 mov %o7, %g1
40007650: 40 00 0a 2e call 40009f08 <_Chain_Insert>
40007654: 9e 10 40 00 mov %g1, %o7
40007834 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
40007834: 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;
40007838: 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 ));
4000783c: 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))
40007840: 80 a7 40 18 cmp %i5, %i0
40007844: 02 80 00 0e be 4000787c <rtems_aio_remove_fd+0x48> <== NEVER TAKEN
40007848: b6 10 20 8c mov 0x8c, %i3
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4000784c: 40 00 09 96 call 40009ea4 <_Chain_Extract>
40007850: 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;
40007854: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
40007858: f8 07 40 00 ld [ %i5 ], %i4
req->aiocbp->return_value = -1;
4000785c: 84 10 3f ff mov -1, %g2
free (req);
40007860: 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;
40007864: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
req->aiocbp->return_value = -1;
free (req);
40007868: 7f ff ee a5 call 400032fc <free>
4000786c: 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))
40007870: 80 a7 00 18 cmp %i4, %i0
40007874: 12 bf ff f6 bne 4000784c <rtems_aio_remove_fd+0x18>
40007878: ba 10 00 1c mov %i4, %i5
4000787c: 81 c7 e0 08 ret
40007880: 81 e8 00 00 restore
40007884 <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)
{
40007884: 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;
40007888: 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 );
4000788c: 84 06 20 04 add %i0, 4, %g2
if (rtems_chain_is_empty (chain))
40007890: 80 a7 40 02 cmp %i5, %g2
40007894: 12 80 00 06 bne 400078ac <rtems_aio_remove_req+0x28>
40007898: b0 10 20 02 mov 2, %i0
4000789c: 30 80 00 12 b,a 400078e4 <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) {
400078a0: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
400078a4: 02 80 00 12 be 400078ec <rtems_aio_remove_req+0x68> <== NOT EXECUTED
400078a8: 01 00 00 00 nop <== NOT EXECUTED
400078ac: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400078b0: 80 a0 40 19 cmp %g1, %i1
400078b4: 32 bf ff fb bne,a 400078a0 <rtems_aio_remove_req+0x1c> <== NEVER TAKEN
400078b8: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
400078bc: 40 00 09 7a call 40009ea4 <_Chain_Extract>
400078c0: 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;
400078c4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
current->aiocbp->return_value = -1;
400078c8: 84 10 3f ff mov -1, %g2
400078cc: 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;
400078d0: 84 10 20 8c mov 0x8c, %g2
current->aiocbp->return_value = -1;
free (current);
400078d4: 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;
400078d8: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
free (current);
400078dc: 7f ff ee 88 call 400032fc <free>
400078e0: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
400078e4: 81 c7 e0 08 ret
400078e8: 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;
400078ec: 81 c7 e0 08 ret <== NOT EXECUTED
400078f0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
4000ec0c <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000ec0c: 9d e3 bf a0 save %sp, -96, %sp
4000ec10: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
4000ec14: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
4000ec18: 10 80 00 04 b 4000ec28 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000ec1c: ba 10 20 01 mov 1, %i5
4000ec20: 02 80 00 0c be 4000ec50 <rtems_assoc_local_by_remote_bitfield+0x44>
4000ec24: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
4000ec28: 80 8f 40 19 btst %i5, %i1
4000ec2c: 22 bf ff fd be,a 4000ec20 <rtems_assoc_local_by_remote_bitfield+0x14>
4000ec30: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
4000ec34: 92 10 00 1d mov %i5, %o1
4000ec38: 40 00 00 08 call 4000ec58 <rtems_assoc_local_by_remote>
4000ec3c: 90 10 00 18 mov %i0, %o0
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
4000ec40: bb 2f 60 01 sll %i5, 1, %i5
4000ec44: b8 87 3f ff addcc %i4, -1, %i4
4000ec48: 12 bf ff f8 bne 4000ec28 <rtems_assoc_local_by_remote_bitfield+0x1c><== ALWAYS TAKEN
4000ec4c: b6 16 c0 08 or %i3, %o0, %i3
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
4000ec50: 81 c7 e0 08 ret
4000ec54: 91 e8 00 1b restore %g0, %i3, %o0
4000bc78 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
4000bc78: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000bc7c: d0 06 00 00 ld [ %i0 ], %o0
4000bc80: 80 a2 20 00 cmp %o0, 0
4000bc84: 02 80 00 1d be 4000bcf8 <rtems_assoc_ptr_by_local+0x80>
4000bc88: 13 10 00 74 sethi %hi(0x4001d000), %o1
4000bc8c: 40 00 12 47 call 400105a8 <strcmp>
4000bc90: 92 12 63 20 or %o1, 0x320, %o1 ! 4001d320 <IMFS_memfile_handlers+0x30>
4000bc94: 80 a2 20 00 cmp %o0, 0
4000bc98: 22 80 00 12 be,a 4000bce0 <rtems_assoc_ptr_by_local+0x68>
4000bc9c: 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;
4000bca0: 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)
4000bca4: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000bca8: 80 a0 40 19 cmp %g1, %i1
4000bcac: 32 80 00 07 bne,a 4000bcc8 <rtems_assoc_ptr_by_local+0x50>
4000bcb0: b0 06 20 0c add %i0, 0xc, %i0
4000bcb4: 30 80 00 13 b,a 4000bd00 <rtems_assoc_ptr_by_local+0x88>
4000bcb8: 80 a0 40 19 cmp %g1, %i1
4000bcbc: 02 80 00 11 be 4000bd00 <rtems_assoc_ptr_by_local+0x88>
4000bcc0: 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++)
4000bcc4: b0 06 20 0c add %i0, 0xc, %i0
4000bcc8: c2 06 00 00 ld [ %i0 ], %g1
4000bccc: 80 a0 60 00 cmp %g1, 0
4000bcd0: 32 bf ff fa bne,a 4000bcb8 <rtems_assoc_ptr_by_local+0x40>
4000bcd4: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000bcd8: 81 c7 e0 08 ret
4000bcdc: 91 e8 00 02 restore %g0, %g2, %o0
4000bce0: 80 a0 a0 00 cmp %g2, 0
4000bce4: 02 80 00 07 be 4000bd00 <rtems_assoc_ptr_by_local+0x88> <== NEVER TAKEN
4000bce8: 82 06 20 0c add %i0, 0xc, %g1
4000bcec: 84 10 00 18 mov %i0, %g2
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
4000bcf0: 10 bf ff ed b 4000bca4 <rtems_assoc_ptr_by_local+0x2c>
4000bcf4: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
4000bcf8: 81 c7 e0 08 ret
4000bcfc: 91 e8 20 00 restore %g0, 0, %o0
4000bd00: 81 c7 e0 08 ret
4000bd04: 81 e8 00 00 restore
40003888 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
40003888: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000388c: fa 06 00 00 ld [ %i0 ], %i5
40003890: 80 a7 60 00 cmp %i5, 0
40003894: 02 80 00 1e be 4000390c <rtems_assoc_ptr_by_name+0x84>
40003898: 90 10 00 1d mov %i5, %o0
4000389c: 13 10 00 58 sethi %hi(0x40016000), %o1
400038a0: 40 00 34 96 call 40010af8 <strcmp>
400038a4: 92 12 60 30 or %o1, 0x30, %o1 ! 40016030 <_rodata_start+0x780>
400038a8: 80 a2 20 00 cmp %o0, 0
400038ac: 22 80 00 10 be,a 400038ec <rtems_assoc_ptr_by_name+0x64>
400038b0: 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;
400038b4: 10 80 00 06 b 400038cc <rtems_assoc_ptr_by_name+0x44>
400038b8: b8 10 20 00 clr %i4
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
400038bc: fa 06 00 00 ld [ %i0 ], %i5
400038c0: 80 a7 60 00 cmp %i5, 0
400038c4: 02 80 00 10 be 40003904 <rtems_assoc_ptr_by_name+0x7c>
400038c8: 01 00 00 00 nop
if (strcmp(ap->name, name) == 0)
400038cc: 90 10 00 1d mov %i5, %o0
400038d0: 40 00 34 8a call 40010af8 <strcmp>
400038d4: 92 10 00 19 mov %i1, %o1
400038d8: 80 a2 20 00 cmp %o0, 0
400038dc: 32 bf ff f8 bne,a 400038bc <rtems_assoc_ptr_by_name+0x34>
400038e0: b0 06 20 0c add %i0, 0xc, %i0
return ap;
return default_ap;
}
400038e4: 81 c7 e0 08 ret
400038e8: 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++)
400038ec: 80 a7 60 00 cmp %i5, 0
400038f0: 02 bf ff fd be 400038e4 <rtems_assoc_ptr_by_name+0x5c> <== NEVER TAKEN
400038f4: 82 06 20 0c add %i0, 0xc, %g1
400038f8: b8 10 00 18 mov %i0, %i4
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
400038fc: 10 bf ff f4 b 400038cc <rtems_assoc_ptr_by_name+0x44>
40003900: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
40003904: 81 c7 e0 08 ret
40003908: 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;
4000390c: 81 c7 e0 08 ret
40003910: 91 e8 20 00 restore %g0, 0, %o0
4000ec94 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000ec94: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000ec98: d0 06 00 00 ld [ %i0 ], %o0
4000ec9c: 80 a2 20 00 cmp %o0, 0
4000eca0: 02 80 00 1d be 4000ed14 <rtems_assoc_ptr_by_remote+0x80>
4000eca4: 13 10 00 74 sethi %hi(0x4001d000), %o1
4000eca8: 40 00 06 40 call 400105a8 <strcmp>
4000ecac: 92 12 63 20 or %o1, 0x320, %o1 ! 4001d320 <IMFS_memfile_handlers+0x30>
4000ecb0: 80 a2 20 00 cmp %o0, 0
4000ecb4: 22 80 00 12 be,a 4000ecfc <rtems_assoc_ptr_by_remote+0x68>
4000ecb8: 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;
4000ecbc: 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)
4000ecc0: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000ecc4: 80 a0 40 19 cmp %g1, %i1
4000ecc8: 32 80 00 07 bne,a 4000ece4 <rtems_assoc_ptr_by_remote+0x50>
4000eccc: b0 06 20 0c add %i0, 0xc, %i0
4000ecd0: 30 80 00 13 b,a 4000ed1c <rtems_assoc_ptr_by_remote+0x88>
4000ecd4: 80 a0 40 19 cmp %g1, %i1
4000ecd8: 02 80 00 11 be 4000ed1c <rtems_assoc_ptr_by_remote+0x88>
4000ecdc: 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++)
4000ece0: b0 06 20 0c add %i0, 0xc, %i0
4000ece4: c2 06 00 00 ld [ %i0 ], %g1
4000ece8: 80 a0 60 00 cmp %g1, 0
4000ecec: 32 bf ff fa bne,a 4000ecd4 <rtems_assoc_ptr_by_remote+0x40>
4000ecf0: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000ecf4: 81 c7 e0 08 ret
4000ecf8: 91 e8 00 02 restore %g0, %g2, %o0
4000ecfc: 80 a0 a0 00 cmp %g2, 0
4000ed00: 02 80 00 07 be 4000ed1c <rtems_assoc_ptr_by_remote+0x88> <== NEVER TAKEN
4000ed04: 82 06 20 0c add %i0, 0xc, %g1
4000ed08: 84 10 00 18 mov %i0, %g2
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
4000ed0c: 10 bf ff ed b 4000ecc0 <rtems_assoc_ptr_by_remote+0x2c>
4000ed10: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
4000ed14: 81 c7 e0 08 ret
4000ed18: 91 e8 20 00 restore %g0, 0, %o0
4000ed1c: 81 c7 e0 08 ret
4000ed20: 81 e8 00 00 restore
400039a4 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
400039a4: 9d e3 bf a0 save %sp, -96, %sp
400039a8: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t remote_value = 0;
400039ac: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1)
400039b0: 10 80 00 04 b 400039c0 <rtems_assoc_remote_by_local_bitfield+0x1c>
400039b4: ba 10 20 01 mov 1, %i5
400039b8: 02 80 00 0c be 400039e8 <rtems_assoc_remote_by_local_bitfield+0x44>
400039bc: bb 2f 60 01 sll %i5, 1, %i5
if (b & local_value)
400039c0: 80 8f 40 19 btst %i5, %i1
400039c4: 22 bf ff fd be,a 400039b8 <rtems_assoc_remote_by_local_bitfield+0x14>
400039c8: b8 87 3f ff addcc %i4, -1, %i4
remote_value |= rtems_assoc_remote_by_local(ap, b);
400039cc: 92 10 00 1d mov %i5, %o1
400039d0: 40 00 00 08 call 400039f0 <rtems_assoc_remote_by_local>
400039d4: 90 10 00 18 mov %i0, %o0
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
400039d8: bb 2f 60 01 sll %i5, 1, %i5
400039dc: b8 87 3f ff addcc %i4, -1, %i4
400039e0: 12 bf ff f8 bne 400039c0 <rtems_assoc_remote_by_local_bitfield+0x1c><== ALWAYS TAKEN
400039e4: b6 16 c0 08 or %i3, %o0, %i3
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
400039e8: 81 c7 e0 08 ret
400039ec: 91 e8 00 1b restore %g0, %i3, %o0
4000cc6c <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4000cc6c: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
4000cc70: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
4000cc74: ba 17 63 34 or %i5, 0x334, %i5 ! 4001af34 <bdbuf_cache>
4000cc78: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
4000cc7c: 80 a0 60 00 cmp %g1, 0
4000cc80: 22 80 00 08 be,a 4000cca0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== ALWAYS TAKEN
4000cc84: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000cc88: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
4000cc8c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
4000cc90: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000cc94: 02 80 00 2b be 4000cd40 <rtems_bdbuf_add_to_modified_list_after_access+0xd4><== NOT EXECUTED
4000cc98: 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
4000cc9c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
4000cca0: 80 a0 60 05 cmp %g1, 5
4000cca4: 22 80 00 16 be,a 4000ccfc <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000cca8: 03 10 00 65 sethi %hi(0x40019400), %g1
4000ccac: 80 a0 60 03 cmp %g1, 3
4000ccb0: 02 80 00 13 be 4000ccfc <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000ccb4: 03 10 00 65 sethi %hi(0x40019400), %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ccb8: 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;
4000ccbc: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
4000ccc0: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
the_node->next = tail;
4000ccc4: 84 07 60 50 add %i5, 0x50, %g2
tail->previous = the_node;
4000ccc8: 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;
4000cccc: 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)
4000ccd0: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
4000ccd4: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000ccd8: 80 a0 a0 00 cmp %g2, 0
4000ccdc: 12 80 00 15 bne 4000cd30 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
4000cce0: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
4000cce4: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
4000cce8: 80 a0 60 00 cmp %g1, 0
4000ccec: 12 80 00 13 bne 4000cd38 <rtems_bdbuf_add_to_modified_list_after_access+0xcc>
4000ccf0: 01 00 00 00 nop
4000ccf4: 81 c7 e0 08 ret
4000ccf8: 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;
4000ccfc: c2 00 62 18 ld [ %g1 + 0x218 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000cd00: 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;
4000cd04: 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;
4000cd08: 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;
4000cd0c: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
the_node->next = tail;
4000cd10: 84 07 60 50 add %i5, 0x50, %g2
tail->previous = the_node;
4000cd14: 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;
4000cd18: 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)
4000cd1c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
4000cd20: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000cd24: 80 a0 a0 00 cmp %g2, 0
4000cd28: 02 bf ff ef be 4000cce4 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
4000cd2c: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000cd30: 7f ff ff c0 call 4000cc30 <rtems_bdbuf_wake>
4000cd34: 91 ef 60 64 restore %i5, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
4000cd38: 7f ff ff 23 call 4000c9c4 <rtems_bdbuf_wake_swapper>
4000cd3c: 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 ();
4000cd40: 7f ff ff 1b call 4000c9ac <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000cd44: 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);
4000cd48: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000cd4c: 7f ff fe f5 call 4000c920 <rtems_bdbuf_lock> <== NOT EXECUTED
4000cd50: 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,
4000cd54: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000cd58: 7f ff ff 0a call 4000c980 <rtems_bdbuf_unlock> <== NOT EXECUTED
4000cd5c: 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 ();
4000cd60: 7f ff fe fd call 4000c954 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000cd64: 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
4000cd68: 10 bf ff ce b 4000cca0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== NOT EXECUTED
4000cd6c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
4000ca6c <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)
{
4000ca6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4000ca70: c2 06 00 00 ld [ %i0 ], %g1
4000ca74: 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 ();
4000ca78: 7f ff ff e0 call 4000c9f8 <rtems_bdbuf_disable_preemption>
4000ca7c: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
4000ca80: 7f ff ff cb call 4000c9ac <rtems_bdbuf_unlock_cache>
4000ca84: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4000ca88: d0 06 20 04 ld [ %i0 + 4 ], %o0
4000ca8c: 92 10 20 00 clr %o1
4000ca90: 7f ff ee ee call 40008648 <rtems_semaphore_obtain>
4000ca94: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
4000ca98: 80 a2 20 06 cmp %o0, 6
4000ca9c: 02 80 00 0d be 4000cad0 <rtems_bdbuf_anonymous_wait+0x64> <== NEVER TAKEN
4000caa0: 80 a2 20 0d cmp %o0, 0xd
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
4000caa4: 12 80 00 0d bne 4000cad8 <rtems_bdbuf_anonymous_wait+0x6c><== NEVER TAKEN
4000caa8: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
rtems_bdbuf_lock_cache ();
4000caac: 7f ff ff aa call 4000c954 <rtems_bdbuf_lock_cache>
4000cab0: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
4000cab4: 7f ff ff df call 4000ca30 <rtems_bdbuf_restore_preemption>
4000cab8: 90 10 00 1d mov %i5, %o0
--waiters->count;
4000cabc: c2 06 00 00 ld [ %i0 ], %g1
4000cac0: 82 00 7f ff add %g1, -1, %g1
4000cac4: c2 26 00 00 st %g1, [ %i0 ]
4000cac8: 81 c7 e0 08 ret
4000cacc: 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);
4000cad0: 7f ff ff 8f call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000cad4: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
4000cad8: 7f ff ff 8d call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000cadc: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
4000cd70 <rtems_bdbuf_create_task.constprop.9>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
4000cd70: 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 ?
4000cd74: 03 10 00 65 sethi %hi(0x40019400), %g1
4000cd78: d4 00 62 24 ld [ %g1 + 0x224 ], %o2 ! 40019624 <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
4000cd7c: 80 a2 a0 00 cmp %o2, 0
4000cd80: 12 80 00 03 bne 4000cd8c <rtems_bdbuf_create_task.constprop.9+0x1c><== ALWAYS TAKEN
4000cd84: 92 10 00 19 mov %i1, %o1
4000cd88: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
4000cd8c: 80 a2 60 00 cmp %o1, 0
4000cd90: 22 80 00 02 be,a 4000cd98 <rtems_bdbuf_create_task.constprop.9+0x28><== NEVER TAKEN
4000cd94: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
4000cd98: 90 10 00 18 mov %i0, %o0
4000cd9c: 96 10 24 00 mov 0x400, %o3
4000cda0: 98 10 20 00 clr %o4
4000cda4: 7f ff ee b8 call 40008884 <rtems_task_create>
4000cda8: 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)
4000cdac: 80 a2 20 00 cmp %o0, 0
4000cdb0: 02 80 00 04 be 4000cdc0 <rtems_bdbuf_create_task.constprop.9+0x50><== ALWAYS TAKEN
4000cdb4: b0 10 00 08 mov %o0, %i0
sc = rtems_task_start (*id, entry, arg);
return sc;
}
4000cdb8: 81 c7 e0 08 ret <== NOT EXECUTED
4000cdbc: 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);
4000cdc0: f0 07 00 00 ld [ %i4 ], %i0
4000cdc4: b2 10 00 1a mov %i2, %i1
4000cdc8: 7f ff ef 3a call 40008ab0 <rtems_task_start>
4000cdcc: 95 e8 00 1b restore %g0, %i3, %o2
4000c9f8 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
4000c9f8: 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);
4000c9fc: 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;
4000ca00: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000ca04: 92 10 21 00 mov 0x100, %o1
4000ca08: 40 00 12 4d call 4001133c <rtems_task_mode>
4000ca0c: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
4000ca10: 80 a2 20 00 cmp %o0, 0
4000ca14: 12 80 00 04 bne 4000ca24 <rtems_bdbuf_disable_preemption+0x2c><== NEVER TAKEN
4000ca18: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
return prev_mode;
}
4000ca1c: 81 c7 e0 08 ret
4000ca20: 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);
4000ca24: 7f ff ff ba call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000ca28: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
4000d1f0 <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)
{
4000d1f0: 9d e3 bf a0 save %sp, -96, %sp
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000d1f4: 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)
4000d1f8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000d1fc: 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)
4000d200: 80 a0 a0 00 cmp %g2, 0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000d204: 86 00 ff ff add %g3, -1, %g3
4000d208: 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;
4000d20c: 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)
4000d210: 02 80 00 05 be 4000d224 <rtems_bdbuf_discard_buffer_after_access+0x34>
4000d214: 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);
4000d218: 31 10 00 6b sethi %hi(0x4001ac00), %i0
4000d21c: 7f ff fe 85 call 4000cc30 <rtems_bdbuf_wake>
4000d220: 91 ee 23 98 restore %i0, 0x398, %o0
4000d224: 7f ff ff e6 call 4000d1bc <rtems_bdbuf_discard_buffer.part.4>
4000d228: 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)
4000d22c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000d230: 80 a0 60 00 cmp %g1, 0
4000d234: 32 bf ff fa bne,a 4000d21c <rtems_bdbuf_discard_buffer_after_access+0x2c><== NEVER TAKEN
4000d238: 31 10 00 6b sethi %hi(0x4001ac00), %i0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000d23c: 31 10 00 6b sethi %hi(0x4001ac00), %i0
4000d240: 7f ff fe 7c call 4000cc30 <rtems_bdbuf_wake>
4000d244: 91 ee 23 a8 restore %i0, 0x3a8, %o0
4000e0cc <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)
{
4000e0cc: 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) +
4000e0d0: 83 2e a0 04 sll %i2, 4, %g1
4000e0d4: 82 00 60 20 add %g1, 0x20, %g1
4000e0d8: 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;
4000e0dc: 03 10 00 38 sethi %hi(0x4000e000), %g1
4000e0e0: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 4000e1a0 <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) +
4000e0e4: 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;
4000e0e8: 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;
4000e0ec: 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;
4000e0f0: 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;
4000e0f4: c2 24 60 04 st %g1, [ %l1 + 4 ]
req->io_task = rtems_task_self ();
4000e0f8: 40 00 0c fd call 400114ec <rtems_task_self>
4000e0fc: 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;
4000e100: 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 ();
4000e104: d0 24 60 14 st %o0, [ %l1 + 0x14 ]
req->bufnum = 0;
4000e108: 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;
4000e10c: 84 10 20 09 mov 9, %g2
4000e110: 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;
4000e114: f2 24 60 24 st %i1, [ %l1 + 0x24 ]
req->bufs [0].block = media_block;
4000e118: f8 24 60 18 st %i4, [ %l1 + 0x18 ]
req->bufs [0].length = block_size;
4000e11c: 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)
4000e120: 80 a6 a0 01 cmp %i2, 1
4000e124: 08 80 00 1d bleu 4000e198 <rtems_bdbuf_execute_read_request+0xcc>
4000e128: c2 24 60 20 st %g1, [ %l1 + 0x20 ]
4000e12c: 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;
4000e130: 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;
4000e134: 10 80 00 0b b 4000e160 <rtems_bdbuf_execute_read_request+0x94>
4000e138: 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;
4000e13c: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
req->bufs [transfer_index].block = media_block;
4000e140: f8 27 60 28 st %i4, [ %i5 + 0x28 ]
req->bufs [transfer_index].length = block_size;
4000e144: e0 27 60 2c st %l0, [ %i5 + 0x2c ]
req->bufs [transfer_index].buffer = bd->buffer;
4000e148: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
4000e14c: 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;
4000e150: 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)
4000e154: 80 a6 c0 1a cmp %i3, %i2
4000e158: 02 80 00 09 be 4000e17c <rtems_bdbuf_execute_read_request+0xb0>
4000e15c: ba 07 60 10 add %i5, 0x10, %i5
{
media_block += media_blocks_per_block;
4000e160: b8 07 00 12 add %i4, %l2, %i4
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
4000e164: 90 10 00 18 mov %i0, %o0
4000e168: 7f ff fd 50 call 4000d6a8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000e16c: 92 10 00 1c mov %i4, %o1
if (bd == NULL)
4000e170: 80 a2 20 00 cmp %o0, 0
4000e174: 32 bf ff f2 bne,a 4000e13c <rtems_bdbuf_execute_read_request+0x70><== ALWAYS TAKEN
4000e178: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4000e17c: f6 24 60 10 st %i3, [ %l1 + 0x10 ]
return rtems_bdbuf_execute_transfer_request (dd, req, true);
4000e180: 90 10 00 18 mov %i0, %o0
4000e184: 92 10 00 11 mov %l1, %o1
4000e188: 7f ff fd f5 call 4000d95c <rtems_bdbuf_execute_transfer_request>
4000e18c: 94 10 20 01 mov 1, %o2
}
4000e190: 81 c7 e0 08 ret
4000e194: 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;
4000e198: 10 bf ff f9 b 4000e17c <rtems_bdbuf_execute_read_request+0xb0>
4000e19c: b6 10 20 01 mov 1, %i3
4000d95c <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)
{
4000d95c: 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)
4000d960: 80 a6 a0 00 cmp %i2, 0
4000d964: 12 80 00 6e bne 4000db1c <rtems_bdbuf_execute_transfer_request+0x1c0>
4000d968: 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);
4000d96c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
4000d970: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000d974: 94 10 00 19 mov %i1, %o2
4000d978: 13 30 06 10 sethi %hi(0xc0184000), %o1
4000d97c: 9f c0 40 00 call %g1
4000d980: 92 12 62 01 or %o1, 0x201, %o1 ! c0184201 <LEON_REG+0x40184201>
/* Wait for transfer request completion */
rtems_bdbuf_wait_for_transient_event ();
4000d984: 7f ff ff e8 call 4000d924 <rtems_bdbuf_wait_for_transient_event>
4000d988: 01 00 00 00 nop
sc = req->status;
rtems_bdbuf_lock_cache ();
4000d98c: 7f ff fb f2 call 4000c954 <rtems_bdbuf_lock_cache>
4000d990: f0 06 60 0c ld [ %i1 + 0xc ], %i0
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
4000d994: c2 06 40 00 ld [ %i1 ], %g1
4000d998: 80 a0 60 00 cmp %g1, 0
4000d99c: 12 80 00 47 bne 4000dab8 <rtems_bdbuf_execute_transfer_request+0x15c>
4000d9a0: c8 06 60 10 ld [ %i1 + 0x10 ], %g4
{
dd->stats.read_blocks += req->bufnum;
4000d9a4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (sc != RTEMS_SUCCESSFUL)
4000d9a8: 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;
4000d9ac: 82 00 40 04 add %g1, %g4, %g1
if (sc != RTEMS_SUCCESSFUL)
4000d9b0: 12 80 00 57 bne 4000db0c <rtems_bdbuf_execute_transfer_request+0x1b0>
4000d9b4: 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)
4000d9b8: 80 a1 20 00 cmp %g4, 0
4000d9bc: 02 80 00 35 be 4000da90 <rtems_bdbuf_execute_transfer_request+0x134><== NEVER TAKEN
4000d9c0: 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;
4000d9c4: 21 10 00 6b sethi %hi(0x4001ac00), %l0
4000d9c8: b8 10 00 19 mov %i1, %i4
4000d9cc: a0 14 23 34 or %l0, 0x334, %l0
4000d9d0: a8 10 20 00 clr %l4
4000d9d4: ba 10 20 00 clr %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000d9d8: a6 10 20 01 mov 1, %l3
4000d9dc: a4 10 20 02 mov 2, %l2
the_node->next = tail;
4000d9e0: 10 80 00 16 b 4000da38 <rtems_bdbuf_execute_transfer_request+0xdc>
4000d9e4: a2 04 20 44 add %l0, 0x44, %l1
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000d9e8: 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)
4000d9ec: 80 a6 20 00 cmp %i0, 0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000d9f0: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4000d9f4: 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)
4000d9f8: 12 80 00 06 bne 4000da10 <rtems_bdbuf_execute_transfer_request+0xb4>
4000d9fc: c6 20 60 0c st %g3, [ %g1 + 0xc ]
4000da00: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
4000da04: 80 a0 60 09 cmp %g1, 9
4000da08: 22 80 00 13 be,a 4000da54 <rtems_bdbuf_execute_transfer_request+0xf8>
4000da0c: 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)
4000da10: 80 a0 a0 00 cmp %g2, 0
4000da14: 12 80 00 05 bne 4000da28 <rtems_bdbuf_execute_transfer_request+0xcc>
4000da18: e6 22 20 20 st %l3, [ %o0 + 0x20 ]
4000da1c: 7f ff fd e8 call 4000d1bc <rtems_bdbuf_discard_buffer.part.4>
4000da20: 01 00 00 00 nop
4000da24: 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)
4000da28: ba 07 60 01 inc %i5
4000da2c: 80 a1 00 1d cmp %g4, %i5
4000da30: 08 80 00 12 bleu 4000da78 <rtems_bdbuf_execute_transfer_request+0x11c><== ALWAYS TAKEN
4000da34: b8 07 20 10 add %i4, 0x10, %i4
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
4000da38: d0 07 20 24 ld [ %i4 + 0x24 ], %o0
bool waiters = bd->waiters;
4000da3c: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
if (waiters)
4000da40: 80 a0 a0 00 cmp %g2, 0
4000da44: 32 bf ff e9 bne,a 4000d9e8 <rtems_bdbuf_execute_transfer_request+0x8c>
4000da48: a8 10 20 01 mov 1, %l4
wake_transfer_waiters = true;
else
wake_buffer_waiters = true;
4000da4c: 10 bf ff e7 b 4000d9e8 <rtems_bdbuf_execute_transfer_request+0x8c>
4000da50: 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;
4000da54: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
4000da58: e2 22 00 00 st %l1, [ %o0 ]
tail->previous = the_node;
4000da5c: d0 24 20 48 st %o0, [ %l0 + 0x48 ]
old_last->next = the_node;
4000da60: d0 20 40 00 st %o0, [ %g1 ]
the_node->previous = old_last;
4000da64: 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)
4000da68: ba 07 60 01 inc %i5
4000da6c: 80 a1 00 1d cmp %g4, %i5
4000da70: 18 bf ff f2 bgu 4000da38 <rtems_bdbuf_execute_transfer_request+0xdc>
4000da74: b8 07 20 10 add %i4, 0x10, %i4
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
4000da78: 80 8d 20 ff btst 0xff, %l4
4000da7c: 12 80 00 2c bne 4000db2c <rtems_bdbuf_execute_transfer_request+0x1d0>
4000da80: 11 10 00 6b sethi %hi(0x4001ac00), %o0
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
4000da84: 80 8e e0 ff btst 0xff, %i3
4000da88: 12 80 00 18 bne 4000dae8 <rtems_bdbuf_execute_transfer_request+0x18c>
4000da8c: 11 10 00 6b sethi %hi(0x4001ac00), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
if (!cache_locked)
4000da90: 80 a6 a0 00 cmp %i2, 0
4000da94: 02 80 00 1a be 4000dafc <rtems_bdbuf_execute_transfer_request+0x1a0>
4000da98: 01 00 00 00 nop
rtems_bdbuf_unlock_cache ();
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
4000da9c: 80 a6 20 0d cmp %i0, 0xd
4000daa0: 02 80 00 04 be 4000dab0 <rtems_bdbuf_execute_transfer_request+0x154>
4000daa4: 80 a6 20 00 cmp %i0, 0
4000daa8: 32 80 00 02 bne,a 4000dab0 <rtems_bdbuf_execute_transfer_request+0x154>
4000daac: b0 10 20 1b mov 0x1b, %i0
return sc;
else
return RTEMS_IO_ERROR;
}
4000dab0: 81 c7 e0 08 ret
4000dab4: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
4000dab8: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
++dd->stats.write_transfers;
4000dabc: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
4000dac0: 84 00 80 04 add %g2, %g4, %g2
++dd->stats.write_transfers;
4000dac4: 82 00 60 01 inc %g1
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
4000dac8: c4 27 60 5c st %g2, [ %i5 + 0x5c ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
4000dacc: 80 a6 20 00 cmp %i0, 0
4000dad0: 02 bf ff ba be 4000d9b8 <rtems_bdbuf_execute_transfer_request+0x5c>
4000dad4: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
++dd->stats.write_errors;
4000dad8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4000dadc: 82 00 60 01 inc %g1
4000dae0: 10 bf ff b6 b 4000d9b8 <rtems_bdbuf_execute_transfer_request+0x5c>
4000dae4: 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);
4000dae8: 7f ff fc 52 call 4000cc30 <rtems_bdbuf_wake>
4000daec: 90 12 23 a8 or %o0, 0x3a8, %o0
if (!cache_locked)
4000daf0: 80 a6 a0 00 cmp %i2, 0
4000daf4: 32 bf ff eb bne,a 4000daa0 <rtems_bdbuf_execute_transfer_request+0x144>
4000daf8: 80 a6 20 0d cmp %i0, 0xd
rtems_bdbuf_unlock_cache ();
4000dafc: 7f ff fb ac call 4000c9ac <rtems_bdbuf_unlock_cache>
4000db00: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
4000db04: 10 bf ff e7 b 4000daa0 <rtems_bdbuf_execute_transfer_request+0x144>
4000db08: 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;
4000db0c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
4000db10: 82 00 60 01 inc %g1
4000db14: 10 bf ff a9 b 4000d9b8 <rtems_bdbuf_execute_transfer_request+0x5c>
4000db18: 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 ();
4000db1c: 7f ff fb a4 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000db20: 01 00 00 00 nop
/* The return value will be ignored for transfer requests */
dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
4000db24: 10 bf ff 93 b 4000d970 <rtems_bdbuf_execute_transfer_request+0x14>
4000db28: 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);
4000db2c: 7f ff fc 41 call 4000cc30 <rtems_bdbuf_wake>
4000db30: 90 12 23 a0 or %o0, 0x3a0, %o0
if (wake_buffer_waiters)
4000db34: 10 bf ff d5 b 4000da88 <rtems_bdbuf_execute_transfer_request+0x12c>
4000db38: 80 8e e0 ff btst 0xff, %i3
4000c90c <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
4000c90c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
4000c910: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
4000c914: 7f ff f1 01 call 40008d18 <rtems_fatal> <== NOT EXECUTED
4000c918: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000c96c <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
4000c96c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
4000c970: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
4000c974: 7f ff ff e6 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c978: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
4000e73c <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000e73c: 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 ();
4000e740: 7f ff f8 85 call 4000c954 <rtems_bdbuf_lock_cache>
4000e744: 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)
4000e748: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000e74c: 80 a6 40 01 cmp %i1, %g1
4000e750: 0a 80 00 07 bcs 4000e76c <rtems_bdbuf_get+0x30> <== ALWAYS TAKEN
4000e754: ba 10 20 00 clr %i5
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000e758: 7f ff f8 95 call 4000c9ac <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000e75c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
*bd_ptr = bd;
4000e760: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
return sc;
}
4000e764: 81 c7 e0 08 ret <== NOT EXECUTED
4000e768: 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)
4000e76c: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
4000e770: 80 a2 60 00 cmp %o1, 0
4000e774: 26 80 00 29 bl,a 4000e818 <rtems_bdbuf_get+0xdc> <== NEVER TAKEN
4000e778: d6 06 20 24 ld [ %i0 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000e77c: 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;
4000e780: 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);
4000e784: 90 10 00 18 mov %i0, %o0
4000e788: 7f ff fb df call 4000d704 <rtems_bdbuf_get_buffer_for_access>
4000e78c: 92 02 40 01 add %o1, %g1, %o1
4000e790: ba 10 00 08 mov %o0, %i5
switch (bd->state)
4000e794: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000e798: 80 a2 20 02 cmp %o0, 2
4000e79c: 02 80 00 17 be 4000e7f8 <rtems_bdbuf_get+0xbc>
4000e7a0: 80 a2 20 07 cmp %o0, 7
4000e7a4: 02 80 00 06 be 4000e7bc <rtems_bdbuf_get+0x80>
4000e7a8: 80 a2 20 01 cmp %o0, 1
4000e7ac: 02 80 00 0c be 4000e7dc <rtems_bdbuf_get+0xa0> <== ALWAYS TAKEN
4000e7b0: 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);
4000e7b4: 7f ff f8 6e call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e7b8: 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;
4000e7bc: 82 10 20 04 mov 4, %g1
4000e7c0: b8 10 20 00 clr %i4
4000e7c4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000e7c8: 7f ff f8 79 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000e7cc: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
4000e7d0: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
4000e7d4: 81 c7 e0 08 ret
4000e7d8: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e7dc: b8 10 20 00 clr %i4
4000e7e0: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000e7e4: 7f ff f8 72 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000e7e8: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
4000e7ec: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
4000e7f0: 81 c7 e0 08 ret
4000e7f4: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e7f8: 82 10 20 03 mov 3, %g1
4000e7fc: b8 10 20 00 clr %i4
4000e800: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000e804: 7f ff f8 6a call 4000c9ac <rtems_bdbuf_unlock_cache>
4000e808: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
4000e80c: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
4000e810: 81 c7 e0 08 ret
4000e814: 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);
4000e818: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000e81c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e820: 40 00 24 5e call 40017998 <__muldi3> <== NOT EXECUTED
4000e824: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000e828: d6 06 20 20 ld [ %i0 + 0x20 ], %o3 <== NOT EXECUTED
4000e82c: 40 00 26 6c call 400181dc <__udivdi3> <== NOT EXECUTED
4000e830: 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;
4000e834: 10 bf ff d4 b 4000e784 <rtems_bdbuf_get+0x48> <== NOT EXECUTED
4000e838: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
4000d704 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
4000d704: 9d e3 bf a0 save %sp, -96, %sp
4000d708: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
4000d70c: b8 10 00 18 mov %i0, %i4
4000d710: ba 17 63 34 or %i5, 0x334, %i5
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000d714: 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);
4000d718: 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);
4000d71c: b4 07 60 64 add %i5, 0x64, %i2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000d720: 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);
4000d724: a2 07 60 74 add %i5, 0x74, %l1
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000d728: a4 07 60 50 add %i5, 0x50, %l2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000d72c: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000d730: 92 10 00 1c mov %i4, %o1
4000d734: 7f ff fd 26 call 4000cbcc <rtems_bdbuf_avl_search.isra.0>
4000d738: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
4000d73c: b0 92 20 00 orcc %o0, 0, %i0
4000d740: 02 80 00 34 be 4000d810 <rtems_bdbuf_get_buffer_for_access+0x10c>
4000d744: 90 10 00 1c mov %i4, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
4000d748: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
4000d74c: c2 07 20 34 ld [ %i4 + 0x34 ], %g1
4000d750: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4000d754: 80 a0 80 01 cmp %g2, %g1
4000d758: 12 80 00 0c bne 4000d788 <rtems_bdbuf_get_buffer_for_access+0x84>
4000d75c: 2d 10 00 31 sethi %hi(0x4000c400), %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);
4000d760: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d764: 39 10 00 31 sethi %hi(0x4000c400), %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);
4000d768: ba 17 63 a0 or %i5, 0x3a0, %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);
4000d76c: b6 07 7f f8 add %i5, -8, %i3
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d770: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000d774: 80 a2 20 0a cmp %o0, 0xa
4000d778: 08 80 00 4c bleu 4000d8a8 <rtems_bdbuf_get_buffer_for_access+0x1a4><== ALWAYS TAKEN
4000d77c: 84 17 23 04 or %i4, 0x304, %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);
4000d780: 7f ff fc 7b call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000d784: 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;
4000d788: aa 10 20 08 mov 8, %l5
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000d78c: a8 07 60 5c add %i5, 0x5c, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d790: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000d794: 80 a2 20 0a cmp %o0, 0xa
4000d798: 08 80 00 04 bleu 4000d7a8 <rtems_bdbuf_get_buffer_for_access+0xa4><== ALWAYS TAKEN
4000d79c: 82 15 a3 30 or %l6, 0x330, %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);
4000d7a0: 7f ff fc 73 call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000d7a4: 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)
4000d7a8: 91 2a 20 02 sll %o0, 2, %o0
4000d7ac: c2 00 40 08 ld [ %g1 + %o0 ], %g1
4000d7b0: 81 c0 40 00 jmp %g1
4000d7b4: 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)
4000d7b8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000d7bc: 80 a0 60 00 cmp %g1, 0
4000d7c0: 12 80 00 1f bne 4000d83c <rtems_bdbuf_get_buffer_for_access+0x138><== ALWAYS TAKEN
4000d7c4: 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);
4000d7c8: 7f ff fe a0 call 4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
4000d7cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000d7d0: 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;
4000d7d4: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000d7d8: f6 26 20 04 st %i3, [ %i0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
4000d7dc: f0 27 60 40 st %i0, [ %i5 + 0x40 ] <== NOT EXECUTED
the_node->next = before_node;
4000d7e0: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
before_node->previous = the_node;
4000d7e4: 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);
4000d7e8: 7f ff fd 12 call 4000cc30 <rtems_bdbuf_wake> <== NOT EXECUTED
4000d7ec: 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);
4000d7f0: d0 07 60 3c ld [ %i5 + 0x3c ], %o0 <== NOT EXECUTED
4000d7f4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4000d7f8: 7f ff fc f5 call 4000cbcc <rtems_bdbuf_avl_search.isra.0> <== NOT EXECUTED
4000d7fc: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
if (bd != NULL)
4000d800: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000d804: 32 bf ff d2 bne,a 4000d74c <rtems_bdbuf_get_buffer_for_access+0x48><== NOT EXECUTED
4000d808: c4 06 20 28 ld [ %i0 + 0x28 ], %g2 <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000d80c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d810: 7f ff fe a0 call 4000d290 <rtems_bdbuf_get_buffer_from_lru_list>
4000d814: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
4000d818: b0 92 20 00 orcc %o0, 0, %i0
4000d81c: 32 bf ff d2 bne,a 4000d764 <rtems_bdbuf_get_buffer_for_access+0x60>
4000d820: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000d824: c2 04 e0 4c ld [ %l3 + 0x4c ], %g1
4000d828: 80 a0 40 12 cmp %g1, %l2
4000d82c: 02 80 00 04 be 4000d83c <rtems_bdbuf_get_buffer_for_access+0x138>
4000d830: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
4000d834: 7f ff fc 64 call 4000c9c4 <rtems_bdbuf_wake_swapper>
4000d838: 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);
4000d83c: 7f ff fc 8c call 4000ca6c <rtems_bdbuf_anonymous_wait>
4000d840: 90 10 00 11 mov %l1, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000d844: 10 bf ff bb b 4000d730 <rtems_bdbuf_get_buffer_for_access+0x2c>
4000d848: 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);
4000d84c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d850: 7f ff fc a5 call 4000cae4 <rtems_bdbuf_wait> <== NOT EXECUTED
4000d854: 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)
4000d858: 10 bf ff cf b 4000d794 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000d85c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000d860: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000d864: 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;
4000d868: ea 26 20 20 st %l5, [ %i0 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
4000d86c: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000d870: 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;
4000d874: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
4000d878: e8 26 00 00 st %l4, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
4000d87c: f0 27 60 60 st %i0, [ %i5 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
4000d880: 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 ();
4000d884: 7f ff fc 50 call 4000c9c4 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
4000d888: 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)
4000d88c: 10 bf ff c2 b 4000d794 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000d890: 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);
4000d894: 90 10 00 18 mov %i0, %o0
4000d898: 7f ff fc 93 call 4000cae4 <rtems_bdbuf_wait>
4000d89c: 92 10 00 1a mov %i2, %o1
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d8a0: 10 bf ff bd b 4000d794 <rtems_bdbuf_get_buffer_for_access+0x90>
4000d8a4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d8a8: 83 2a 20 02 sll %o0, 2, %g1
4000d8ac: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000d8b0: 81 c0 40 00 jmp %g1
4000d8b4: 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);
4000d8b8: 90 10 00 18 mov %i0, %o0
4000d8bc: 7f ff fc 8a call 4000cae4 <rtems_bdbuf_wait>
4000d8c0: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d8c4: 10 bf ff ac b 4000d774 <rtems_bdbuf_get_buffer_for_access+0x70>
4000d8c8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000d8cc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000d8d0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000d8d4: 84 00 bf ff add %g2, -1, %g2
4000d8d8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000d8dc: c6 06 00 00 ld [ %i0 ], %g3
previous = the_node->previous;
4000d8e0: c4 06 20 04 ld [ %i0 + 4 ], %g2
next->previous = previous;
4000d8e4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000d8e8: c6 20 80 00 st %g3, [ %g2 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4000d8ec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000d8f0: 84 00 a0 01 inc %g2
4000d8f4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
4000d8f8: 81 c7 e0 08 ret
4000d8fc: 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);
4000d900: 90 10 00 18 mov %i0, %o0
4000d904: 7f ff fc 78 call 4000cae4 <rtems_bdbuf_wait>
4000d908: 92 10 00 1b mov %i3, %o1
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000d90c: 10 bf ff 9a b 4000d774 <rtems_bdbuf_get_buffer_for_access+0x70>
4000d910: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000d914: 10 bf ff f2 b 4000d8dc <rtems_bdbuf_get_buffer_for_access+0x1d8>
4000d918: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000d91c: 10 bf ff f4 b 4000d8ec <rtems_bdbuf_get_buffer_for_access+0x1e8>
4000d920: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000d6a8 <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)
{
4000d6a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000d6ac: 03 10 00 6b sethi %hi(0x4001ac00), %g1
4000d6b0: d0 00 63 70 ld [ %g1 + 0x370 ], %o0 ! 4001af70 <bdbuf_cache+0x3c>
4000d6b4: 92 10 00 18 mov %i0, %o1
4000d6b8: 7f ff fd 45 call 4000cbcc <rtems_bdbuf_avl_search.isra.0>
4000d6bc: 94 10 00 19 mov %i1, %o2
if (bd == NULL)
4000d6c0: 80 a2 20 00 cmp %o0, 0
4000d6c4: 02 80 00 04 be 4000d6d4 <rtems_bdbuf_get_buffer_for_read_ahead+0x2c><== ALWAYS TAKEN
4000d6c8: 82 10 20 00 clr %g1
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
4000d6cc: 81 c7 e0 08 ret <== NOT EXECUTED
4000d6d0: 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);
4000d6d4: 90 10 00 18 mov %i0, %o0
4000d6d8: 7f ff fe ee call 4000d290 <rtems_bdbuf_get_buffer_from_lru_list>
4000d6dc: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
4000d6e0: 82 92 20 00 orcc %o0, 0, %g1
4000d6e4: 02 bf ff fa be 4000d6cc <rtems_bdbuf_get_buffer_for_read_ahead+0x24><== NEVER TAKEN
4000d6e8: 01 00 00 00 nop
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4000d6ec: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
4000d6f0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4000d6f4: 86 00 e0 01 inc %g3
4000d6f8: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
4000d6fc: 81 c7 e0 08 ret
4000d700: 91 e8 00 01 restore %g0, %g1, %o0
4000d290 <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)
{
4000d290: 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;
4000d294: 35 10 00 6b sethi %hi(0x4001ac00), %i2
4000d298: b4 16 a3 34 or %i2, 0x334, %i2 ! 4001af34 <bdbuf_cache>
4000d29c: 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))
4000d2a0: a4 06 a0 44 add %i2, 0x44, %l2
4000d2a4: a6 06 a0 40 add %i2, 0x40, %l3
4000d2a8: 80 a7 40 12 cmp %i5, %l2
4000d2ac: 12 80 00 07 bne 4000d2c8 <rtems_bdbuf_get_buffer_from_lru_list+0x38>
4000d2b0: a8 06 a0 74 add %i2, 0x74, %l4
}
node = rtems_chain_next (node);
}
return NULL;
4000d2b4: 10 80 00 6c b 4000d464 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000d2b8: 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))
4000d2bc: 80 a7 40 12 cmp %i5, %l2
4000d2c0: 22 80 00 69 be,a 4000d464 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000d2c4: 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)
4000d2c8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d2cc: 80 a0 60 00 cmp %g1, 0
4000d2d0: 32 bf ff fb bne,a 4000d2bc <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000d2d4: fa 07 40 00 ld [ %i5 ], %i5
{
if (bd->group->bds_per_group == dd->bds_per_group)
4000d2d8: e0 07 60 28 ld [ %i5 + 0x28 ], %l0
4000d2dc: e2 06 20 34 ld [ %i0 + 0x34 ], %l1
4000d2e0: f6 04 20 08 ld [ %l0 + 8 ], %i3
4000d2e4: 80 a6 c0 11 cmp %i3, %l1
4000d2e8: 02 80 00 37 be 4000d3c4 <rtems_bdbuf_get_buffer_from_lru_list+0x134>
4000d2ec: 01 00 00 00 nop
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
4000d2f0: c2 04 20 0c ld [ %l0 + 0xc ], %g1
4000d2f4: 80 a0 60 00 cmp %g1, 0
4000d2f8: 32 bf ff f1 bne,a 4000d2bc <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000d2fc: 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;
4000d300: ec 06 a0 20 ld [ %i2 + 0x20 ], %l6
4000d304: 92 10 00 1b mov %i3, %o1
4000d308: 40 00 28 4c call 40017438 <.udiv>
4000d30c: 90 10 00 16 mov %l6, %o0
for (b = 0, bd = group->bdbuf;
4000d310: 80 a6 e0 00 cmp %i3, 0
4000d314: 02 80 00 0f be 4000d350 <rtems_bdbuf_get_buffer_from_lru_list+0xc0><== NEVER TAKEN
4000d318: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
4000d31c: 83 2a 20 03 sll %o0, 3, %g1
4000d320: ab 2a 20 06 sll %o0, 6, %l5
4000d324: b6 10 20 00 clr %i3
4000d328: 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);
4000d32c: 7f ff ff c7 call 4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000d330: 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;
4000d334: c2 04 20 08 ld [ %l0 + 8 ], %g1
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000d338: 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;
4000d33c: 80 a6 c0 01 cmp %i3, %g1
4000d340: 0a bf ff fb bcs 4000d32c <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
4000d344: b8 07 00 15 add %i4, %l5, %i4
4000d348: ec 06 a0 20 ld [ %i2 + 0x20 ], %l6
4000d34c: 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;
4000d350: e2 24 20 08 st %l1, [ %l0 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4000d354: 90 10 00 16 mov %l6, %o0
4000d358: 40 00 28 38 call 40017438 <.udiv>
4000d35c: 92 10 00 11 mov %l1, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4000d360: 83 2a 20 03 sll %o0, 3, %g1
4000d364: 89 2a 20 06 sll %o0, 6, %g4
4000d368: 80 a4 60 01 cmp %l1, 1
4000d36c: 88 21 00 01 sub %g4, %g1, %g4
4000d370: 08 80 00 10 bleu 4000d3b0 <rtems_bdbuf_get_buffer_from_lru_list+0x120>
4000d374: 82 07 00 04 add %i4, %g4, %g1
4000d378: 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;
4000d37c: c0 20 60 20 clr [ %g1 + 0x20 ]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000d380: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000d384: e6 20 60 04 st %l3, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000d388: c2 26 a0 40 st %g1, [ %i2 + 0x40 ]
the_node->next = before_node;
4000d38c: c6 20 40 00 st %g3, [ %g1 ]
before_node->previous = the_node;
4000d390: 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)
4000d394: 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;
4000d398: 80 a0 80 11 cmp %g2, %l1
4000d39c: 12 bf ff f8 bne 4000d37c <rtems_bdbuf_get_buffer_from_lru_list+0xec>
4000d3a0: 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);
4000d3a4: 7f ff fe 23 call 4000cc30 <rtems_bdbuf_wake>
4000d3a8: 90 10 00 14 mov %l4, %o0
4000d3ac: 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)
4000d3b0: 80 a7 20 00 cmp %i4, 0
4000d3b4: 22 bf ff c2 be,a 4000d2bc <rtems_bdbuf_get_buffer_from_lru_list+0x2c><== NEVER TAKEN
4000d3b8: 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;
4000d3bc: 10 80 00 04 b 4000d3cc <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
4000d3c0: 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);
4000d3c4: 7f ff ff a1 call 4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000d3c8: 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 ;
4000d3cc: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
4000d3d0: c0 27 60 08 clr [ %i5 + 8 ]
bd->avl.right = NULL;
4000d3d4: 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;
4000d3d8: 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;
4000d3dc: 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)
4000d3e0: 80 a0 60 00 cmp %g1, 0
4000d3e4: 02 80 00 5c be 4000d554 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
4000d3e8: c0 27 60 24 clr [ %i5 + 0x24 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000d3ec: 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;
4000d3f0: 9e 07 bf 80 add %fp, -128, %o7
4000d3f4: 84 10 00 0f mov %o7, %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4000d3f8: 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;
4000d3fc: b8 10 20 01 mov 1, %i4
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000d400: b6 10 3f ff mov -1, %i3
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000d404: 80 a0 c0 18 cmp %g3, %i0
4000d408: 1a 80 00 0d bcc 4000d43c <rtems_bdbuf_get_buffer_from_lru_list+0x1ac><== ALWAYS TAKEN
4000d40c: 88 00 a0 04 add %g2, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
q = p->avl.right;
4000d410: c6 00 60 0c ld [ %g1 + 0xc ], %g3 <== NOT EXECUTED
if (q == NULL)
4000d414: 80 a0 e0 00 cmp %g3, 0
4000d418: 02 80 00 1d be 4000d48c <rtems_bdbuf_get_buffer_from_lru_list+0x1fc>
4000d41c: 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)
4000d420: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000d424: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
4000d428: 84 10 00 04 mov %g4, %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4000d42c: c2 20 80 00 st %g1, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000d430: 80 a0 c0 18 cmp %g3, %i0
4000d434: 0a bf ff f7 bcs 4000d410 <rtems_bdbuf_get_buffer_from_lru_list+0x180><== NEVER TAKEN
4000d438: 88 00 a0 04 add %g2, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
4000d43c: 80 a6 00 03 cmp %i0, %g3
4000d440: 22 80 00 0b be,a 4000d46c <rtems_bdbuf_get_buffer_from_lru_list+0x1dc><== ALWAYS TAKEN
4000d444: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
q = p->avl.left;
4000d448: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
if (q == NULL)
4000d44c: 80 a0 e0 00 cmp %g3, 0
4000d450: 12 bf ff f4 bne 4000d420 <rtems_bdbuf_get_buffer_from_lru_list+0x190>
4000d454: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
4000d458: fa 20 60 08 st %i5, [ %g1 + 8 ]
4000d45c: 10 80 00 0e b 4000d494 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
4000d460: 88 10 3f ff mov -1, %g4
node = rtems_chain_next (node);
}
return NULL;
}
4000d464: 81 c7 e0 08 ret
4000d468: 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)))
4000d46c: 80 a6 40 03 cmp %i1, %g3
4000d470: 38 bf ff e9 bgu,a 4000d414 <rtems_bdbuf_get_buffer_from_lru_list+0x184>
4000d474: c6 00 60 0c ld [ %g1 + 0xc ], %g3
q = node;
p->avl.right = q = node;
break;
}
}
else if ((p->dd != dd) || (p->block != block))
4000d478: 80 a6 40 03 cmp %i1, %g3
4000d47c: 32 bf ff f4 bne,a 4000d44c <rtems_bdbuf_get_buffer_from_lru_list+0x1bc><== ALWAYS TAKEN
4000d480: 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);
4000d484: 7f ff fd 22 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d488: 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;
4000d48c: fa 20 60 0c st %i5, [ %g1 + 0xc ]
4000d490: 88 10 20 01 mov 1, %g4
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4000d494: c0 27 60 0c clr [ %i5 + 0xc ]
4000d498: c0 27 60 08 clr [ %i5 + 8 ]
q->avl.bal = 0;
4000d49c: c0 2f 60 11 clrb [ %i5 + 0x11 ]
4000d4a0: 89 29 20 18 sll %g4, 0x18, %g4
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
4000d4a4: 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;
4000d4a8: 10 80 00 12 b 4000d4f0 <rtems_bdbuf_get_buffer_from_lru_list+0x260>
4000d4ac: b0 10 3f ff mov -1, %i0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
4000d4b0: 86 10 00 01 mov %g1, %g3
4000d4b4: b8 10 20 01 mov 1, %i4
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000d4b8: 80 a0 80 0f cmp %g2, %o7
4000d4bc: 28 80 00 1e bleu,a 4000d534 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000d4c0: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
p = *--buf_prev;
4000d4c4: c2 00 bf fc ld [ %g2 + -4 ], %g1
if (p->avl.cache == -1)
4000d4c8: c8 08 60 10 ldub [ %g1 + 0x10 ], %g4
4000d4cc: 89 29 20 18 sll %g4, 0x18, %g4
4000d4d0: b7 39 20 18 sra %g4, 0x18, %i3
4000d4d4: 80 a6 ff ff cmp %i3, -1
4000d4d8: 22 80 00 03 be,a 4000d4e4 <rtems_bdbuf_get_buffer_from_lru_list+0x254>
4000d4dc: c6 20 60 08 st %g3, [ %g1 + 8 ]
{
p->avl.left = q;
}
else
{
p->avl.right = q;
4000d4e0: 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)
4000d4e4: 80 8f 20 ff btst 0xff, %i4
4000d4e8: 02 80 00 13 be 4000d534 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000d4ec: 84 00 bf fc add %g2, -4, %g2
{
if (p->avl.cache == -1)
4000d4f0: 89 39 20 18 sra %g4, 0x18, %g4
4000d4f4: 80 a1 3f ff cmp %g4, -1
4000d4f8: 02 80 00 1e be 4000d570 <rtems_bdbuf_get_buffer_from_lru_list+0x2e0>
4000d4fc: c6 48 60 11 ldsb [ %g1 + 0x11 ], %g3
break;
}
}
else
{
switch (p->avl.bal)
4000d500: 80 a0 e0 00 cmp %g3, 0
4000d504: 22 bf ff eb be,a 4000d4b0 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
4000d508: f2 28 60 11 stb %i1, [ %g1 + 0x11 ]
4000d50c: 80 a0 e0 01 cmp %g3, 1
4000d510: 02 80 00 1f be 4000d58c <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
4000d514: 80 a0 ff ff cmp %g3, -1
4000d518: 22 80 00 0c be,a 4000d548 <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== ALWAYS TAKEN
4000d51c: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000d520: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000d524: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
4000d528: 18 bf ff e7 bgu 4000d4c4 <rtems_bdbuf_get_buffer_from_lru_list+0x234><== NOT EXECUTED
4000d52c: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
4000d530: 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;
4000d534: 82 10 20 01 mov 1, %g1
4000d538: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
node = rtems_chain_next (node);
}
return NULL;
}
4000d53c: 81 c7 e0 08 ret
4000d540: 91 e8 00 1d restore %g0, %i5, %o0
else
{
switch (p->avl.bal)
{
case -1:
p->avl.bal = 0;
4000d544: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000d548: 86 10 00 01 mov %g1, %g3
modified = false;
4000d54c: 10 bf ff db b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d550: b8 10 20 00 clr %i4
bool modified = false;
if (p == NULL)
{
*root = node;
4000d554: 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;
4000d558: 82 10 20 01 mov 1, %g1
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
4000d55c: c0 27 60 08 clr [ %i5 + 8 ]
node->avl.right = NULL;
4000d560: c0 27 60 0c clr [ %i5 + 0xc ]
node->avl.bal = 0;
4000d564: 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;
4000d568: 10 bf ff f5 b 4000d53c <rtems_bdbuf_get_buffer_from_lru_list+0x2ac>
4000d56c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
4000d570: 80 a0 e0 00 cmp %g3, 0
4000d574: 12 80 00 20 bne 4000d5f4 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000d578: 80 a0 e0 01 cmp %g3, 1
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
4000d57c: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
4000d580: 86 10 00 01 mov %g1, %g3
4000d584: 10 bf ff cd b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d588: b8 10 20 01 mov 1, %i4
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
4000d58c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
if (p1->avl.bal == 1) /* simple RR-turn */
4000d590: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
4000d594: 80 a0 e0 01 cmp %g3, 1
4000d598: 02 80 00 32 be 4000d660 <rtems_bdbuf_get_buffer_from_lru_list+0x3d0>
4000d59c: c6 01 20 08 ld [ %g4 + 8 ], %g3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000d5a0: 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;
4000d5a4: f8 48 e0 11 ldsb [ %g3 + 0x11 ], %i4
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000d5a8: f6 21 20 08 st %i3, [ %g4 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000d5ac: 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;
4000d5b0: c8 20 e0 0c st %g4, [ %g3 + 0xc ]
p->avl.right = p2->avl.left;
4000d5b4: 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;
4000d5b8: 80 a7 20 01 cmp %i4, 1
4000d5bc: 02 80 00 30 be 4000d67c <rtems_bdbuf_get_buffer_from_lru_list+0x3ec><== NEVER TAKEN
4000d5c0: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000d5c4: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4000d5c8: c2 48 e0 11 ldsb [ %g3 + 0x11 ], %g1
4000d5cc: 80 a0 7f ff cmp %g1, -1
4000d5d0: 22 80 00 06 be,a 4000d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x358><== NEVER TAKEN
4000d5d4: f2 29 20 11 stb %i1, [ %g4 + 0x11 ] <== NOT EXECUTED
4000d5d8: c0 29 20 11 clrb [ %g4 + 0x11 ]
p = p2;
}
p->avl.bal = 0;
4000d5dc: c0 28 e0 11 clrb [ %g3 + 0x11 ]
modified = false;
4000d5e0: 10 bf ff b6 b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d5e4: 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;
4000d5e8: c0 28 e0 11 clrb [ %g3 + 0x11 ] <== NOT EXECUTED
modified = false;
4000d5ec: 10 bf ff b3 b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228><== NOT EXECUTED
4000d5f0: b8 10 20 00 clr %i4 <== NOT EXECUTED
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
4000d5f4: 02 bf ff d4 be 4000d544 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4>
4000d5f8: 80 a0 ff ff cmp %g3, -1
4000d5fc: 32 bf ff ca bne,a 4000d524 <rtems_bdbuf_get_buffer_from_lru_list+0x294><== NEVER TAKEN
4000d600: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
4000d604: c8 00 60 08 ld [ %g1 + 8 ], %g4
if (p1->avl.bal == -1) /* simple LL-turn */
4000d608: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
4000d60c: 80 a0 ff ff cmp %g3, -1
4000d610: 02 80 00 1d be 4000d684 <rtems_bdbuf_get_buffer_from_lru_list+0x3f4>
4000d614: c6 01 20 0c ld [ %g4 + 0xc ], %g3
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000d618: 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;
4000d61c: f8 48 e0 11 ldsb [ %g3 + 0x11 ], %i4
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000d620: f6 21 20 0c st %i3, [ %g4 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000d624: 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;
4000d628: c8 20 e0 08 st %g4, [ %g3 + 8 ]
p->avl.left = p2->avl.right;
4000d62c: 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;
4000d630: 80 a7 3f ff cmp %i4, -1
4000d634: 02 80 00 1b be 4000d6a0 <rtems_bdbuf_get_buffer_from_lru_list+0x410>
4000d638: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
4000d63c: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000d640: c2 48 e0 11 ldsb [ %g3 + 0x11 ], %g1
4000d644: 80 a0 60 01 cmp %g1, 1
4000d648: 32 bf ff e5 bne,a 4000d5dc <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
4000d64c: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000d650: 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;
4000d654: c0 28 e0 11 clrb [ %g3 + 0x11 ]
modified = false;
4000d658: 10 bf ff 98 b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d65c: 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;
4000d660: c6 20 60 0c st %g3, [ %g1 + 0xc ]
p1->avl.left = p;
p->avl.bal = 0;
4000d664: 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;
4000d668: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.bal = 0;
4000d66c: 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;
4000d670: 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;
4000d674: 10 bf ff 91 b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d678: 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;
4000d67c: 10 bf ff d3 b 4000d5c8 <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
4000d680: 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;
4000d684: c6 20 60 08 st %g3, [ %g1 + 8 ]
p1->avl.right = p;
p->avl.bal = 0;
4000d688: 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;
4000d68c: c2 21 20 0c st %g1, [ %g4 + 0xc ]
p->avl.bal = 0;
4000d690: 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;
4000d694: 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;
4000d698: 10 bf ff 88 b 4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d69c: 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;
4000d6a0: 10 bf ff e8 b 4000d640 <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
4000d6a4: f2 28 60 11 stb %i1, [ %g1 + 0x11 ]
4000e310 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
4000e310: 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())
4000e314: 03 10 00 6d sethi %hi(0x4001b400), %g1
4000e318: c2 00 63 e8 ld [ %g1 + 0x3e8 ], %g1 ! 4001b7e8 <_Per_CPU_Information+0x8>
4000e31c: 80 a0 60 00 cmp %g1, 0
4000e320: 12 80 00 16 bne 4000e378 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
4000e324: 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)
4000e328: 3b 10 00 65 sethi %hi(0x40019400), %i5
4000e32c: ba 17 62 08 or %i5, 0x208, %i5 ! 40019608 <rtems_bdbuf_configuration>
4000e330: f4 07 60 28 ld [ %i5 + 0x28 ], %i2
4000e334: f6 07 60 24 ld [ %i5 + 0x24 ], %i3
4000e338: 90 10 00 1a mov %i2, %o0
4000e33c: 92 10 00 1b mov %i3, %o1
4000e340: 40 00 24 ea call 400176e8 <.urem>
4000e344: b0 10 20 0a mov 0xa, %i0
4000e348: 80 a2 20 00 cmp %o0, 0
4000e34c: 12 80 00 fa bne 4000e734 <rtems_bdbuf_init+0x424> <== NEVER TAKEN
4000e350: 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 ();
4000e354: 7f ff f9 a9 call 4000c9f8 <rtems_bdbuf_disable_preemption>
4000e358: 33 10 00 6b sethi %hi(0x4001ac00), %i1
if (bdbuf_cache.initialised)
4000e35c: b8 16 63 34 or %i1, 0x334, %i4 ! 4001af34 <bdbuf_cache>
4000e360: c2 0f 20 95 ldub [ %i4 + 0x95 ], %g1
4000e364: 80 a0 60 00 cmp %g1, 0
4000e368: 02 80 00 06 be 4000e380 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
4000e36c: b0 10 00 08 mov %o0, %i0
{
rtems_bdbuf_restore_preemption (prev_mode);
4000e370: 7f ff f9 b0 call 4000ca30 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
4000e374: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
4000e378: 81 c7 e0 08 ret <== NOT EXECUTED
4000e37c: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4000e380: 92 10 20 00 clr %o1
4000e384: 94 10 20 98 mov 0x98, %o2
4000e388: 40 00 19 17 call 400147e4 <memset>
4000e38c: 90 10 00 1c mov %i4, %o0
bdbuf_cache.initialised = true;
4000e390: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
4000e394: 90 10 00 18 mov %i0, %o0
4000e398: 7f ff f9 a6 call 4000ca30 <rtems_bdbuf_restore_preemption>
4000e39c: 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;
4000e3a0: 82 07 20 0c add %i4, 0xc, %g1
4000e3a4: c2 27 20 08 st %g1, [ %i4 + 8 ]
head->previous = NULL;
tail->previous = head;
4000e3a8: 82 07 20 08 add %i4, 8, %g1
4000e3ac: 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;
4000e3b0: 82 07 20 50 add %i4, 0x50, %g1
head->previous = NULL;
tail->previous = head;
4000e3b4: 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;
4000e3b8: c2 27 20 4c st %g1, [ %i4 + 0x4c ]
4000e3bc: 82 07 20 5c add %i4, 0x5c, %g1
head->previous = NULL;
tail->previous = head;
4000e3c0: 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;
4000e3c4: c2 27 20 58 st %g1, [ %i4 + 0x58 ]
head->previous = NULL;
tail->previous = head;
4000e3c8: 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;
4000e3cc: 82 07 20 8c add %i4, 0x8c, %g1
head->previous = NULL;
tail->previous = head;
4000e3d0: 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;
4000e3d4: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
head->previous = NULL;
tail->previous = head;
4000e3d8: 84 07 20 58 add %i4, 0x58, %g2
4000e3dc: 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;
4000e3e0: 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;
4000e3e4: c0 27 20 38 clr [ %i4 + 0x38 ]
head->previous = NULL;
4000e3e8: c0 27 20 0c clr [ %i4 + 0xc ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000e3ec: e0 27 20 40 st %l0, [ %i4 + 0x40 ]
head->previous = NULL;
4000e3f0: c0 27 20 44 clr [ %i4 + 0x44 ]
4000e3f4: c0 27 20 50 clr [ %i4 + 0x50 ]
4000e3f8: c0 27 20 5c clr [ %i4 + 0x5c ]
tail->previous = head;
4000e3fc: 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;
4000e400: 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'),
4000e404: 31 10 91 10 sethi %hi(0x42444000), %i0
tail->previous = head;
4000e408: c2 27 20 90 st %g1, [ %i4 + 0x90 ]
4000e40c: 90 16 23 6c or %i0, 0x36c, %o0
4000e410: 92 10 20 01 mov 1, %o1
4000e414: 94 10 20 54 mov 0x54, %o2
4000e418: 96 10 20 00 clr %o3
4000e41c: 7f ff e7 e3 call 400083a8 <rtems_semaphore_create>
4000e420: 98 07 20 28 add %i4, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
4000e424: 80 a2 20 00 cmp %o0, 0
4000e428: 02 80 00 2d be 4000e4dc <rtems_bdbuf_init+0x1cc> <== ALWAYS TAKEN
4000e42c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
4000e430: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
4000e434: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e438: 12 80 00 25 bne 4000e4cc <rtems_bdbuf_init+0x1bc> <== NOT EXECUTED
4000e43c: 01 00 00 00 nop <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
4000e440: d0 06 63 34 ld [ %i1 + 0x334 ], %o0 <== NOT EXECUTED
4000e444: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e448: 12 80 00 1e bne 4000e4c0 <rtems_bdbuf_init+0x1b0> <== NOT EXECUTED
4000e44c: 01 00 00 00 nop <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
free (bdbuf_cache.buffers);
4000e450: 7f ff d7 00 call 40004050 <free> <== NOT EXECUTED
4000e454: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
4000e458: 7f ff d6 fe call 40004050 <free> <== NOT EXECUTED
4000e45c: d0 07 20 80 ld [ %i4 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
4000e460: 7f ff d6 fc call 40004050 <free> <== NOT EXECUTED
4000e464: d0 07 20 14 ld [ %i4 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
4000e468: 7f ff e8 41 call 4000856c <rtems_semaphore_delete> <== NOT EXECUTED
4000e46c: d0 07 20 78 ld [ %i4 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
4000e470: 7f ff e8 3f call 4000856c <rtems_semaphore_delete> <== NOT EXECUTED
4000e474: d0 07 20 68 ld [ %i4 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
4000e478: 7f ff e8 3d call 4000856c <rtems_semaphore_delete> <== NOT EXECUTED
4000e47c: d0 07 20 70 ld [ %i4 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
4000e480: 7f ff e8 3b call 4000856c <rtems_semaphore_delete> <== NOT EXECUTED
4000e484: d0 07 20 2c ld [ %i4 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
4000e488: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 <== NOT EXECUTED
4000e48c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000e490: 12 80 00 05 bne 4000e4a4 <rtems_bdbuf_init+0x194> <== NOT EXECUTED
4000e494: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
4000e498: c0 2f 20 95 clrb [ %i4 + 0x95 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
4000e49c: 81 c7 e0 08 ret <== NOT EXECUTED
4000e4a0: 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 ();
4000e4a4: 7f ff f9 42 call 4000c9ac <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000e4a8: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
4000e4ac: 7f ff e8 30 call 4000856c <rtems_semaphore_delete> <== NOT EXECUTED
4000e4b0: d0 07 20 28 ld [ %i4 + 0x28 ], %o0 <== NOT EXECUTED
4000e4b4: c0 2f 20 95 clrb [ %i4 + 0x95 ] <== NOT EXECUTED
4000e4b8: 81 c7 e0 08 ret <== NOT EXECUTED
4000e4bc: 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);
4000e4c0: 7f ff e9 3a call 400089a8 <rtems_task_delete> <== NOT EXECUTED
4000e4c4: 01 00 00 00 nop <== NOT EXECUTED
4000e4c8: 30 bf ff e2 b,a 4000e450 <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);
4000e4cc: 7f ff e9 37 call 400089a8 <rtems_task_delete> <== NOT EXECUTED
4000e4d0: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
4000e4d4: 10 bf ff dc b 4000e444 <rtems_bdbuf_init+0x134> <== NOT EXECUTED
4000e4d8: d0 06 63 34 ld [ %i1 + 0x334 ], %o0 <== NOT EXECUTED
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
goto error;
rtems_bdbuf_lock_cache ();
4000e4dc: 7f ff f9 1e call 4000c954 <rtems_bdbuf_lock_cache>
4000e4e0: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
4000e4e4: 90 16 23 73 or %i0, 0x373, %o0
4000e4e8: 92 10 20 01 mov 1, %o1
4000e4ec: 94 10 20 54 mov 0x54, %o2
4000e4f0: 96 10 20 00 clr %o3
4000e4f4: 7f ff e7 ad call 400083a8 <rtems_semaphore_create>
4000e4f8: 98 07 20 2c add %i4, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
4000e4fc: 80 a2 20 00 cmp %o0, 0
4000e500: 32 bf ff cd bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e504: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
4000e508: 90 16 23 61 or %i0, 0x361, %o0
4000e50c: 92 10 20 00 clr %o1
4000e510: 94 10 20 24 mov 0x24, %o2
4000e514: 96 10 20 00 clr %o3
4000e518: 7f ff e7 a4 call 400083a8 <rtems_semaphore_create>
4000e51c: 98 07 20 68 add %i4, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000e520: 80 a2 20 00 cmp %o0, 0
4000e524: 32 bf ff c4 bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e528: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
4000e52c: 90 16 23 74 or %i0, 0x374, %o0
4000e530: 92 10 20 00 clr %o1
4000e534: 94 10 20 24 mov 0x24, %o2
4000e538: 96 10 20 00 clr %o3
4000e53c: 7f ff e7 9b call 400083a8 <rtems_semaphore_create>
4000e540: 98 07 20 70 add %i4, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000e544: 80 a2 20 00 cmp %o0, 0
4000e548: 32 bf ff bb bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e54c: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
4000e550: 90 16 23 62 or %i0, 0x362, %o0
4000e554: 92 10 20 00 clr %o1
4000e558: 94 10 20 24 mov 0x24, %o2
4000e55c: 96 10 20 00 clr %o3
4000e560: 7f ff e7 92 call 400083a8 <rtems_semaphore_create>
4000e564: 98 07 20 78 add %i4, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000e568: 80 a2 20 00 cmp %o0, 0
4000e56c: 32 bf ff b2 bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e570: 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;
4000e574: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000e578: 40 00 23 b0 call 40017438 <.udiv>
4000e57c: 92 10 00 1b mov %i3, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
4000e580: 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;
4000e584: b0 10 00 08 mov %o0, %i0
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
4000e588: 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;
4000e58c: 40 00 23 ab call 40017438 <.udiv>
4000e590: 90 10 00 1a mov %i2, %o0
4000e594: 82 10 00 08 mov %o0, %g1
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000e598: 90 10 00 18 mov %i0, %o0
4000e59c: 92 10 00 01 mov %g1, %o1
4000e5a0: 40 00 23 a6 call 40017438 <.udiv>
4000e5a4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000e5a8: 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 =
4000e5ac: d0 27 20 7c st %o0, [ %i4 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000e5b0: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000e5b4: 7f ff d6 70 call 40003f74 <calloc>
4000e5b8: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4000e5bc: 80 a2 20 00 cmp %o0, 0
4000e5c0: 02 bf ff 9c be 4000e430 <rtems_bdbuf_init+0x120> <== NEVER TAKEN
4000e5c4: 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),
4000e5c8: 90 10 20 14 mov 0x14, %o0
4000e5cc: 7f ff d6 6a call 40003f74 <calloc>
4000e5d0: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4000e5d4: 80 a2 20 00 cmp %o0, 0
4000e5d8: 02 bf ff 96 be 4000e430 <rtems_bdbuf_init+0x120> <== NEVER TAKEN
4000e5dc: 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)
4000e5e0: 92 10 00 1b mov %i3, %o1
4000e5e4: 40 00 23 5b call 40017350 <.umul>
4000e5e8: 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,
4000e5ec: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000e5f0: 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,
4000e5f4: 11 10 00 6b sethi %hi(0x4001ac00), %o0
4000e5f8: 40 00 07 73 call 400103c4 <rtems_memalign>
4000e5fc: 90 12 23 4c or %o0, 0x34c, %o0 ! 4001af4c <bdbuf_cache+0x18>
4000e600: 80 a2 20 00 cmp %o0, 0
4000e604: 32 bf ff 8c bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e608: 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,
4000e60c: f0 07 20 80 ld [ %i4 + 0x80 ], %i0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000e610: 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) ==
4000e614: 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;
4000e618: e8 07 20 18 ld [ %i4 + 0x18 ], %l4
b < bdbuf_cache.buffer_min_count;
4000e61c: 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))
4000e620: 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;
4000e624: 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,
4000e628: a6 10 00 18 mov %i0, %l3
4000e62c: a4 10 20 00 clr %l2
4000e630: 80 a4 80 17 cmp %l2, %l7
4000e634: 02 80 00 13 be 4000e680 <rtems_bdbuf_init+0x370>
4000e638: 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;
4000e63c: e6 26 a0 28 st %l3, [ %i2 + 0x28 ]
bd->buffer = buffer;
4000e640: 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;
4000e644: 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;
4000e648: c2 07 20 48 ld [ %i4 + 0x48 ], %g1
the_node->next = tail;
4000e64c: e0 26 80 00 st %l0, [ %i2 ]
tail->previous = the_node;
4000e650: f4 27 20 48 st %i2, [ %i4 + 0x48 ]
old_last->next = the_node;
4000e654: f4 20 40 00 st %i2, [ %g1 ]
the_node->previous = old_last;
4000e658: 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) ==
4000e65c: 40 00 24 23 call 400176e8 <.urem>
4000e660: 92 10 00 15 mov %l5, %o1
4000e664: 80 a2 00 16 cmp %o0, %l6
4000e668: 22 80 00 02 be,a 4000e670 <rtems_bdbuf_init+0x360>
4000e66c: 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)
4000e670: a4 04 a0 01 inc %l2
4000e674: b4 06 a0 38 add %i2, 0x38, %i2
4000e678: 10 bf ff ee b 4000e630 <rtems_bdbuf_init+0x320>
4000e67c: 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;
4000e680: c4 07 20 20 ld [ %i4 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
4000e684: f6 07 20 7c ld [ %i4 + 0x7c ], %i3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
4000e688: 87 28 a0 03 sll %g2, 3, %g3
4000e68c: 89 28 a0 06 sll %g2, 6, %g4
4000e690: 82 10 20 00 clr %g1
4000e694: 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,
4000e698: 80 a0 40 1b cmp %g1, %i3
4000e69c: 02 80 00 07 be 4000e6b8 <rtems_bdbuf_init+0x3a8>
4000e6a0: 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;
4000e6a4: 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;
4000e6a8: 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++,
4000e6ac: b0 06 20 14 add %i0, 0x14, %i0
bd += bdbuf_cache.max_bds_per_group)
4000e6b0: 10 bf ff fa b 4000e698 <rtems_bdbuf_init+0x388>
4000e6b4: 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'),
4000e6b8: 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;
4000e6bc: b6 10 20 01 mov 1, %i3
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000e6c0: 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;
4000e6c4: f6 2f 20 04 stb %i3, [ %i4 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000e6c8: 90 12 23 50 or %o0, 0x350, %o0
4000e6cc: 96 10 20 00 clr %o3
4000e6d0: 15 10 00 37 sethi %hi(0x4000dc00), %o2
4000e6d4: 98 10 00 1c mov %i4, %o4
4000e6d8: 7f ff f9 a6 call 4000cd70 <rtems_bdbuf_create_task.constprop.9>
4000e6dc: 94 12 a0 a4 or %o2, 0xa4, %o2
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
4000e6e0: 80 a2 20 00 cmp %o0, 0
4000e6e4: 32 bf ff 54 bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e6e8: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
4000e6ec: 03 10 00 65 sethi %hi(0x40019400), %g1
4000e6f0: c2 00 62 08 ld [ %g1 + 0x208 ], %g1 ! 40019608 <rtems_bdbuf_configuration>
4000e6f4: 80 a0 60 00 cmp %g1, 0
4000e6f8: 02 80 00 0d be 4000e72c <rtems_bdbuf_init+0x41c>
4000e6fc: 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'),
4000e700: 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;
4000e704: f6 2f 20 94 stb %i3, [ %i4 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000e708: 15 10 00 38 sethi %hi(0x4000e000), %o2
4000e70c: 90 12 20 41 or %o0, 0x41, %o0
4000e710: 94 12 a1 bc or %o2, 0x1bc, %o2
4000e714: 96 10 20 00 clr %o3
4000e718: 7f ff f9 96 call 4000cd70 <rtems_bdbuf_create_task.constprop.9>
4000e71c: 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)
4000e720: 80 a2 20 00 cmp %o0, 0
4000e724: 32 bf ff 44 bne,a 4000e434 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000e728: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
}
rtems_bdbuf_unlock_cache ();
4000e72c: 7f ff f8 a0 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000e730: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000e734: 81 c7 e0 08 ret
4000e738: 81 e8 00 00 restore
4000c920 <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)
{
4000c920: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
4000c924: 92 10 20 00 clr %o1
4000c928: 90 10 00 18 mov %i0, %o0
4000c92c: 7f ff ef 47 call 40008648 <rtems_semaphore_obtain>
4000c930: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4000c934: 80 a2 20 00 cmp %o0, 0
4000c938: 12 80 00 04 bne 4000c948 <rtems_bdbuf_lock+0x28> <== NEVER TAKEN
4000c93c: 01 00 00 00 nop
4000c940: 81 c7 e0 08 ret
4000c944: 81 e8 00 00 restore
rtems_bdbuf_fatal (fatal_error_code);
4000c948: 7f ff ff f1 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c94c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000ed54 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
4000ed54: 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;
4000ed58: b4 07 bf 74 add %fp, -140, %i2
4000ed5c: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
4000ed60: c0 27 bf 78 clr [ %fp + -136 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000ed64: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
4000ed68: 7f ff f6 fb call 4000c954 <rtems_bdbuf_lock_cache>
4000ed6c: 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);
4000ed70: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
4000ed74: 80 a0 60 00 cmp %g1, 0
4000ed78: 02 80 00 70 be 4000ef38 <rtems_bdbuf_purge_dev+0x1e4> <== ALWAYS TAKEN
4000ed7c: 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;
4000ed80: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
4000ed84: 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;
4000ed88: c0 26 20 68 clr [ %i0 + 0x68 ] <== NOT EXECUTED
4000ed8c: 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;
4000ed90: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED
4000ed94: 82 10 63 34 or %g1, 0x334, %g1 ! 4001af34 <bdbuf_cache>
4000ed98: 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;
4000ed9c: 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;
4000eda0: 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;
4000eda4: 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)
4000eda8: 80 a7 60 00 cmp %i5, 0
4000edac: 02 80 00 2e be 4000ee64 <rtems_bdbuf_purge_dev+0x110>
4000edb0: b8 07 bf 80 add %fp, -128, %i4
{
if (cur->dd == dd)
{
switch (cur->state)
4000edb4: 33 10 00 31 sethi %hi(0x4000c400), %i1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000edb8: a2 10 20 06 mov 6, %l1
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4000edbc: b2 16 63 5c or %i1, 0x35c, %i1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000edc0: 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);
4000edc4: 10 80 00 09 b 4000ede8 <rtems_bdbuf_purge_dev+0x94>
4000edc8: a0 00 60 6c add %g1, 0x6c, %l0
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
}
}
if (cur->avl.left != NULL)
4000edcc: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000edd0: 80 a0 60 00 cmp %g1, 0
4000edd4: 22 80 00 0f be,a 4000ee10 <rtems_bdbuf_purge_dev+0xbc>
4000edd8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
4000eddc: fa 27 20 04 st %i5, [ %i4 + 4 ]
4000ede0: ba 10 00 01 mov %g1, %i5
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
4000ede4: b8 07 20 04 add %i4, 4, %i4
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
4000ede8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000edec: 80 a6 00 01 cmp %i0, %g1
4000edf0: 32 bf ff f8 bne,a 4000edd0 <rtems_bdbuf_purge_dev+0x7c>
4000edf4: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
switch (cur->state)
4000edf8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000edfc: 80 a0 60 0a cmp %g1, 0xa
4000ee00: 28 80 00 34 bleu,a 4000eed0 <rtems_bdbuf_purge_dev+0x17c><== ALWAYS TAKEN
4000ee04: 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);
4000ee08: 7f ff f6 c1 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000ee0c: 90 10 20 17 mov 0x17, %o0 <== NOT EXECUTED
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
4000ee10: 80 a0 60 00 cmp %g1, 0
4000ee14: 32 bf ff f3 bne,a 4000ede0 <rtems_bdbuf_purge_dev+0x8c>
4000ee18: fa 27 20 04 st %i5, [ %i4 + 4 ]
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
4000ee1c: c2 07 00 00 ld [ %i4 ], %g1
4000ee20: 80 a0 60 00 cmp %g1, 0
4000ee24: 32 80 00 06 bne,a 4000ee3c <rtems_bdbuf_purge_dev+0xe8>
4000ee28: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000ee2c: 10 80 00 0f b 4000ee68 <rtems_bdbuf_purge_dev+0x114>
4000ee30: d0 07 bf 74 ld [ %fp + -140 ], %o0
4000ee34: 82 10 00 02 mov %g2, %g1
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
4000ee38: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000ee3c: 80 a0 80 1d cmp %g2, %i5
4000ee40: 02 80 00 04 be 4000ee50 <rtems_bdbuf_purge_dev+0xfc>
4000ee44: 80 a0 a0 00 cmp %g2, 0
4000ee48: 32 bf ff e8 bne,a 4000ede8 <rtems_bdbuf_purge_dev+0x94>
4000ee4c: ba 10 00 02 mov %g2, %i5
{
/* Up */
cur = *prev;
--prev;
4000ee50: b8 07 3f fc add %i4, -4, %i4
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
4000ee54: c4 07 00 00 ld [ %i4 ], %g2
4000ee58: 80 a0 a0 00 cmp %g2, 0
4000ee5c: 12 bf ff f6 bne 4000ee34 <rtems_bdbuf_purge_dev+0xe0>
4000ee60: ba 10 00 01 mov %g1, %i5
4000ee64: d0 07 bf 74 ld [ %fp + -140 ], %o0
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
4000ee68: 86 10 20 00 clr %g3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ee6c: 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))
4000ee70: 80 a2 00 1b cmp %o0, %i3
4000ee74: 02 80 00 0f be 4000eeb0 <rtems_bdbuf_purge_dev+0x15c>
4000ee78: 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;
4000ee7c: 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)
4000ee80: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
head->next = new_first;
4000ee84: c2 27 bf 74 st %g1, [ %fp + -140 ]
4000ee88: 80 a0 a0 00 cmp %g2, 0
4000ee8c: 12 80 00 28 bne 4000ef2c <rtems_bdbuf_purge_dev+0x1d8>
4000ee90: 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;
4000ee94: 7f ff f8 ca call 4000d1bc <rtems_bdbuf_discard_buffer.part.4>
4000ee98: fa 22 20 20 st %i5, [ %o0 + 0x20 ]
4000ee9c: 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))
4000eea0: 80 a2 00 1b cmp %o0, %i3
4000eea4: 12 bf ff f6 bne 4000ee7c <rtems_bdbuf_purge_dev+0x128>
4000eea8: 86 10 20 01 mov 1, %g3
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
4000eeac: 80 88 e0 ff btst 0xff, %g3
4000eeb0: 02 80 00 04 be 4000eec0 <rtems_bdbuf_purge_dev+0x16c>
4000eeb4: 11 10 00 6b sethi %hi(0x4001ac00), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000eeb8: 7f ff f7 5e call 4000cc30 <rtems_bdbuf_wake>
4000eebc: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 4001afa8 <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 ();
4000eec0: 7f ff f6 bb call 4000c9ac <rtems_bdbuf_unlock_cache>
4000eec4: 01 00 00 00 nop
4000eec8: 81 c7 e0 08 ret
4000eecc: 81 e8 00 00 restore
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4000eed0: c4 06 40 01 ld [ %i1 + %g1 ], %g2
4000eed4: 81 c0 80 00 jmp %g2
4000eed8: 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);
4000eedc: 7f ff f7 55 call 4000cc30 <rtems_bdbuf_wake>
4000eee0: 90 10 00 10 mov %l0, %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000eee4: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
4000eee8: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
4000eeec: 82 00 7f ff add %g1, -1, %g1
4000eef0: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000eef4: c4 07 60 04 ld [ %i5 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000eef8: c6 07 40 00 ld [ %i5 ], %g3
previous = the_node->previous;
next->previous = previous;
4000eefc: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000ef00: 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;
4000ef04: c4 07 bf 7c ld [ %fp + -132 ], %g2
the_node->next = tail;
4000ef08: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
4000ef0c: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
4000ef10: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
4000ef14: 10 bf ff ae b 4000edcc <rtems_bdbuf_purge_dev+0x78>
4000ef18: 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;
4000ef1c: 10 bf ff ac b 4000edcc <rtems_bdbuf_purge_dev+0x78>
4000ef20: e2 27 60 20 st %l1, [ %i5 + 0x20 ]
4000ef24: 10 bf ff aa b 4000edcc <rtems_bdbuf_purge_dev+0x78>
4000ef28: e4 27 60 20 st %l2, [ %i5 + 0x20 ]
4000ef2c: fa 22 20 20 st %i5, [ %o0 + 0x20 ]
4000ef30: 10 bf ff d0 b 4000ee70 <rtems_bdbuf_purge_dev+0x11c>
4000ef34: 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);
4000ef38: 80 a0 a0 00 cmp %g2, 0
4000ef3c: 32 bf ff 92 bne,a 4000ed84 <rtems_bdbuf_purge_dev+0x30> <== NEVER TAKEN
4000ef40: 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;
4000ef44: 10 bf ff 94 b 4000ed94 <rtems_bdbuf_purge_dev+0x40>
4000ef48: 03 10 00 6b sethi %hi(0x4001ac00), %g1
4000e83c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000e83c: 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 ();
4000e840: 7f ff f8 45 call 4000c954 <rtems_bdbuf_lock_cache>
4000e844: 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)
4000e848: 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;
4000e84c: 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)
4000e850: 80 a6 40 01 cmp %i1, %g1
4000e854: 0a 80 00 07 bcs 4000e870 <rtems_bdbuf_read+0x34> <== ALWAYS TAKEN
4000e858: b0 10 20 04 mov 4, %i0
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
4000e85c: 7f ff f8 54 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000e860: 01 00 00 00 nop
*bd_ptr = bd;
4000e864: f8 26 80 00 st %i4, [ %i2 ]
4000e868: 81 c7 e0 08 ret
4000e86c: 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)
4000e870: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000e874: 80 a2 60 00 cmp %o1, 0
4000e878: 26 80 00 60 bl,a 4000e9f8 <rtems_bdbuf_read+0x1bc> <== NEVER TAKEN
4000e87c: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000e880: 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;
4000e884: 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);
4000e888: 90 10 00 1d mov %i5, %o0
4000e88c: 7f ff fb 9e call 4000d704 <rtems_bdbuf_get_buffer_for_access>
4000e890: 92 02 40 01 add %o1, %g1, %o1
4000e894: b8 10 00 08 mov %o0, %i4
switch (bd->state)
4000e898: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000e89c: 80 a2 20 02 cmp %o0, 2
4000e8a0: 02 80 00 4f be 4000e9dc <rtems_bdbuf_read+0x1a0>
4000e8a4: 80 a2 20 07 cmp %o0, 7
4000e8a8: 02 80 00 06 be 4000e8c0 <rtems_bdbuf_read+0x84>
4000e8ac: 80 a2 20 01 cmp %o0, 1
4000e8b0: 22 80 00 28 be,a 4000e950 <rtems_bdbuf_read+0x114> <== ALWAYS TAKEN
4000e8b4: c4 07 60 48 ld [ %i5 + 0x48 ], %g2
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4000e8b8: 7f ff f8 2d call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e8bc: 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;
4000e8c0: 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;
4000e8c4: 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;
4000e8c8: 82 00 60 01 inc %g1
4000e8cc: 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;
4000e8d0: 82 10 20 04 mov 4, %g1
4000e8d4: 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
4000e8d8: 37 10 00 6b sethi %hi(0x4001ac00), %i3
4000e8dc: b6 16 e3 34 or %i3, 0x334, %i3 ! 4001af34 <bdbuf_cache>
4000e8e0: d0 06 e0 84 ld [ %i3 + 0x84 ], %o0
4000e8e4: 80 a2 20 00 cmp %o0, 0
4000e8e8: 02 bf ff dd be 4000e85c <rtems_bdbuf_read+0x20>
4000e8ec: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
4000e8f0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
4000e8f4: 80 a6 40 01 cmp %i1, %g1
4000e8f8: 12 bf ff d9 bne 4000e85c <rtems_bdbuf_read+0x20>
4000e8fc: 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);
4000e900: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
4000e904: 80 a0 60 00 cmp %g1, 0
4000e908: 12 bf ff d5 bne 4000e85c <rtems_bdbuf_read+0x20> <== NEVER TAKEN
4000e90c: 01 00 00 00 nop
4000e910: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
4000e914: 80 a0 60 00 cmp %g1, 0
4000e918: 12 bf ff d1 bne 4000e85c <rtems_bdbuf_read+0x20> <== NEVER TAKEN
4000e91c: 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))
4000e920: c2 06 e0 88 ld [ %i3 + 0x88 ], %g1
4000e924: b2 06 e0 8c add %i3, 0x8c, %i1
4000e928: 80 a0 40 19 cmp %g1, %i1
4000e92c: 02 80 00 41 be 4000ea30 <rtems_bdbuf_read+0x1f4> <== ALWAYS TAKEN
4000e930: 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;
4000e934: 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);
4000e938: 84 07 60 64 add %i5, 0x64, %g2
the_node->next = tail;
4000e93c: f2 27 60 64 st %i1, [ %i5 + 0x64 ]
tail->previous = the_node;
4000e940: c4 26 e0 90 st %g2, [ %i3 + 0x90 ]
old_last->next = the_node;
4000e944: c4 20 40 00 st %g2, [ %g1 ]
the_node->previous = old_last;
4000e948: 10 bf ff c5 b 4000e85c <rtems_bdbuf_read+0x20>
4000e94c: 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)
4000e950: 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;
4000e954: 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)
4000e958: 80 a6 40 01 cmp %i1, %g1
4000e95c: 02 80 00 0e be 4000e994 <rtems_bdbuf_read+0x158>
4000e960: 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);
4000e964: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
4000e968: 80 a0 60 00 cmp %g1, 0
4000e96c: 02 80 00 2c be 4000ea1c <rtems_bdbuf_read+0x1e0> <== ALWAYS TAKEN
4000e970: 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;
4000e974: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
4000e978: 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;
4000e97c: c0 27 60 68 clr [ %i5 + 0x68 ] <== NOT EXECUTED
4000e980: c0 27 60 64 clr [ %i5 + 0x64 ] <== NOT EXECUTED
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
4000e984: 84 06 60 01 add %i1, 1, %g2 <== NOT EXECUTED
dd->read_ahead.next = block + 2;
4000e988: 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;
4000e98c: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
4000e990: 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);
4000e994: 90 10 00 1d mov %i5, %o0
4000e998: 92 10 00 1c mov %i4, %o1
4000e99c: 7f ff fd cc call 4000e0cc <rtems_bdbuf_execute_read_request>
4000e9a0: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
4000e9a4: b0 92 20 00 orcc %o0, 0, %i0
4000e9a8: 32 bf ff cc bne,a 4000e8d8 <rtems_bdbuf_read+0x9c>
4000e9ac: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4000e9b0: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000e9b4: c4 07 20 04 ld [ %i4 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000e9b8: c6 07 00 00 ld [ %i4 ], %g3
4000e9bc: 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;
4000e9c0: b6 10 20 03 mov 3, %i3
4000e9c4: f6 27 20 20 st %i3, [ %i4 + 0x20 ]
previous = the_node->previous;
next->previous = previous;
4000e9c8: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000e9cc: c6 20 80 00 st %g3, [ %g2 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4000e9d0: 84 01 20 01 add %g4, 1, %g2
4000e9d4: 10 bf ff c1 b 4000e8d8 <rtems_bdbuf_read+0x9c>
4000e9d8: 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;
4000e9dc: 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;
4000e9e0: 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;
4000e9e4: 82 00 60 01 inc %g1
4000e9e8: 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;
4000e9ec: 82 10 20 03 mov 3, %g1
4000e9f0: 10 bf ff ba b 4000e8d8 <rtems_bdbuf_read+0x9c>
4000e9f4: 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);
4000e9f8: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000e9fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000ea00: 40 00 23 e6 call 40017998 <__muldi3> <== NOT EXECUTED
4000ea04: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000ea08: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
4000ea0c: 40 00 25 f4 call 400181dc <__udivdi3> <== NOT EXECUTED
4000ea10: 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;
4000ea14: 10 bf ff 9d b 4000e888 <rtems_bdbuf_read+0x4c> <== NOT EXECUTED
4000ea18: 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);
4000ea1c: 80 a0 a0 00 cmp %g2, 0
4000ea20: 32 bf ff d5 bne,a 4000e974 <rtems_bdbuf_read+0x138> <== NEVER TAKEN
4000ea24: 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;
4000ea28: 10 bf ff d8 b 4000e988 <rtems_bdbuf_read+0x14c>
4000ea2c: 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,
4000ea30: 7f ff e5 cd call 40008164 <rtems_event_send>
4000ea34: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
4000ea38: 80 a2 20 00 cmp %o0, 0
4000ea3c: 22 bf ff bf be,a 4000e938 <rtems_bdbuf_read+0xfc> <== ALWAYS TAKEN
4000ea40: c2 06 e0 90 ld [ %i3 + 0x90 ], %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
4000ea44: 7f ff f7 b2 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000ea48: 90 10 20 07 mov 7, %o0 <== NOT EXECUTED
4000e1bc <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
4000e1bc: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
4000e1c0: 37 10 00 6b sethi %hi(0x4001ac00), %i3
4000e1c4: b6 16 e3 34 or %i3, 0x334, %i3 ! 4001af34 <bdbuf_cache>
4000e1c8: c2 0e e0 94 ldub [ %i3 + 0x94 ], %g1
4000e1cc: 80 a0 60 00 cmp %g1, 0
4000e1d0: 02 80 00 22 be 4000e258 <rtems_bdbuf_read_ahead_task+0x9c><== NEVER TAKEN
4000e1d4: b0 06 e0 88 add %i3, 0x88, %i0
4000e1d8: 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;
4000e1dc: 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;
4000e1e0: 23 10 00 65 sethi %hi(0x40019400), %l1
while (bdbuf_cache.read_ahead_enabled)
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
4000e1e4: 7f ff fa 53 call 4000cb30 <rtems_bdbuf_wait_for_event>
4000e1e8: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
4000e1ec: 7f ff f9 da call 4000c954 <rtems_bdbuf_lock_cache>
4000e1f0: 01 00 00 00 nop
4000e1f4: 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))
4000e1f8: 80 a7 40 19 cmp %i5, %i1
4000e1fc: 02 80 00 11 be 4000e240 <rtems_bdbuf_read_ahead_task+0x84>
4000e200: 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;
4000e204: 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;
4000e208: 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)
4000e20c: c4 07 7f c4 ld [ %i5 + -60 ], %g2
head->next = new_first;
4000e210: c2 26 a0 88 st %g1, [ %i2 + 0x88 ]
4000e214: 80 a7 00 02 cmp %i4, %g2
4000e218: 0a 80 00 12 bcs 4000e260 <rtems_bdbuf_read_ahead_task+0xa4>
4000e21c: f0 20 60 04 st %i0, [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4000e220: c0 27 60 04 clr [ %i5 + 4 ]
4000e224: 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;
4000e228: 82 10 3f ff mov -1, %g1
4000e22c: 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;
4000e230: 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))
4000e234: 80 a7 40 19 cmp %i5, %i1
4000e238: 32 bf ff f4 bne,a 4000e208 <rtems_bdbuf_read_ahead_task+0x4c><== NEVER TAKEN
4000e23c: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
}
}
rtems_bdbuf_unlock_cache ();
4000e240: 7f ff f9 db call 4000c9ac <rtems_bdbuf_unlock_cache>
4000e244: 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)
4000e248: c2 0e a0 94 ldub [ %i2 + 0x94 ], %g1
4000e24c: 80 a0 60 00 cmp %g1, 0
4000e250: 12 bf ff e5 bne 4000e1e4 <rtems_bdbuf_read_ahead_task+0x28><== ALWAYS TAKEN
4000e254: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
4000e258: 7f ff e9 d4 call 400089a8 <rtems_task_delete> <== NOT EXECUTED
4000e25c: 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)
4000e260: d2 07 7f cc ld [ %i5 + -52 ], %o1
4000e264: 80 a2 60 00 cmp %o1, 0
4000e268: 26 80 00 21 bl,a 4000e2ec <rtems_bdbuf_read_ahead_task+0x130><== NEVER TAKEN
4000e26c: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000e270: 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;
4000e274: 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 *)
4000e278: 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 =
4000e27c: 92 02 40 01 add %o1, %g1, %o1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4000e280: c0 27 60 04 clr [ %i5 + 4 ]
4000e284: c0 27 40 00 clr [ %i5 ]
4000e288: 7f ff fd 08 call 4000d6a8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000e28c: 90 10 00 10 mov %l0, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
4000e290: 92 92 20 00 orcc %o0, 0, %o1
4000e294: 02 bf ff d8 be 4000e1f4 <rtems_bdbuf_read_ahead_task+0x38><== NEVER TAKEN
4000e298: c2 04 62 08 ld [ %l1 + 0x208 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
4000e29c: d4 07 7f c4 ld [ %i5 + -60 ], %o2
4000e2a0: 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)
4000e2a4: 80 a2 80 01 cmp %o2, %g1
4000e2a8: 2a 80 00 0f bcs,a 4000e2e4 <rtems_bdbuf_read_ahead_task+0x128>
4000e2ac: 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;
4000e2b0: 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;
4000e2b4: 87 30 60 01 srl %g1, 1, %g3
dd->read_ahead.next = block + transfer_count;
4000e2b8: 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;
4000e2bc: b8 00 c0 1c add %g3, %i4, %i4
dd->read_ahead.next = block + transfer_count;
4000e2c0: 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;
4000e2c4: f8 27 60 08 st %i4, [ %i5 + 8 ]
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
4000e2c8: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000e2cc: 90 10 00 10 mov %l0, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
4000e2d0: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000e2d4: 7f ff ff 7e call 4000e0cc <rtems_bdbuf_execute_read_request>
4000e2d8: 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;
4000e2dc: 10 bf ff c7 b 4000e1f8 <rtems_bdbuf_read_ahead_task+0x3c>
4000e2e0: 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;
4000e2e4: 10 bf ff f9 b 4000e2c8 <rtems_bdbuf_read_ahead_task+0x10c>
4000e2e8: 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);
4000e2ec: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000e2f0: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000e2f4: 40 00 25 a9 call 40017998 <__muldi3> <== NOT EXECUTED
4000e2f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000e2fc: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
4000e300: 40 00 27 b7 call 400181dc <__udivdi3> <== NOT EXECUTED
4000e304: 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;
4000e308: 10 bf ff dc b 4000e278 <rtems_bdbuf_read_ahead_task+0xbc> <== NOT EXECUTED
4000e30c: c2 07 7f b4 ld [ %i5 + -76 ], %g1 <== NOT EXECUTED
4000ea50 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
4000ea50: 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)
4000ea54: 80 a6 20 00 cmp %i0, 0
4000ea58: 02 80 00 0f be 4000ea94 <rtems_bdbuf_release+0x44> <== NEVER TAKEN
4000ea5c: 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();
4000ea60: 7f ff f7 bd call 4000c954 <rtems_bdbuf_lock_cache>
4000ea64: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4000ea68: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000ea6c: 80 a2 20 04 cmp %o0, 4
4000ea70: 02 80 00 14 be 4000eac0 <rtems_bdbuf_release+0x70>
4000ea74: 01 00 00 00 nop
4000ea78: 18 80 00 09 bgu 4000ea9c <rtems_bdbuf_release+0x4c>
4000ea7c: 80 a2 20 06 cmp %o0, 6
4000ea80: 80 a2 20 03 cmp %o0, 3
4000ea84: 22 80 00 15 be,a 4000ead8 <rtems_bdbuf_release+0x88> <== ALWAYS TAKEN
4000ea88: 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);
4000ea8c: 7f ff f7 b8 call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000ea90: 92 10 20 0e mov 0xe, %o1 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
4000ea94: 81 c7 e0 08 ret <== NOT EXECUTED
4000ea98: 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)
4000ea9c: 18 bf ff fc bgu 4000ea8c <rtems_bdbuf_release+0x3c> <== NEVER TAKEN
4000eaa0: 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);
4000eaa4: 90 10 00 18 mov %i0, %o0
4000eaa8: 7f ff f9 d2 call 4000d1f0 <rtems_bdbuf_discard_buffer_after_access>
4000eaac: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000eab0: 7f ff f7 bf call 4000c9ac <rtems_bdbuf_unlock_cache>
4000eab4: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4000eab8: 81 c7 e0 08 ret
4000eabc: 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);
4000eac0: 7f ff f8 6b call 4000cc6c <rtems_bdbuf_add_to_modified_list_after_access>
4000eac4: 90 10 00 18 mov %i0, %o0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000eac8: 7f ff f7 b9 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000eacc: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000ead0: 81 c7 e0 08 ret
4000ead4: 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;
4000ead8: 11 10 00 6b sethi %hi(0x4001ac00), %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000eadc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000eae0: 90 12 23 34 or %o0, 0x334, %o0
4000eae4: 84 00 bf ff add %g2, -1, %g2
4000eae8: 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;
4000eaec: 82 10 20 02 mov 2, %g1
the_node->next = tail;
4000eaf0: 84 02 20 44 add %o0, 0x44, %g2
4000eaf4: 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;
4000eaf8: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
4000eafc: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
4000eb00: 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)
4000eb04: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
old_last->next = the_node;
the_node->previous = old_last;
4000eb08: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000eb0c: 80 a0 a0 00 cmp %g2, 0
4000eb10: 12 80 00 05 bne 4000eb24 <rtems_bdbuf_release+0xd4>
4000eb14: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000eb18: 7f ff f8 46 call 4000cc30 <rtems_bdbuf_wake>
4000eb1c: 90 02 20 74 add %o0, 0x74, %o0
4000eb20: 30 bf ff ea b,a 4000eac8 <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);
4000eb24: 7f ff f8 43 call 4000cc30 <rtems_bdbuf_wake>
4000eb28: 90 02 20 64 add %o0, 0x64, %o0
4000eb2c: 30 bf ff e7 b,a 4000eac8 <rtems_bdbuf_release+0x78>
4000eb30 <rtems_bdbuf_release_modified>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
4000eb30: 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)
4000eb34: 80 a6 20 00 cmp %i0, 0
4000eb38: 02 80 00 13 be 4000eb84 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4000eb3c: 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();
4000eb40: 7f ff f7 85 call 4000c954 <rtems_bdbuf_lock_cache>
4000eb44: 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)
4000eb48: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000eb4c: 80 a2 20 03 cmp %o0, 3
4000eb50: 1a 80 00 04 bcc 4000eb60 <rtems_bdbuf_release_modified+0x30><== ALWAYS TAKEN
4000eb54: 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);
4000eb58: 7f ff f7 85 call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000eb5c: 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)
4000eb60: 18 80 00 0b bgu 4000eb8c <rtems_bdbuf_release_modified+0x5c>
4000eb64: 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);
4000eb68: 90 10 00 18 mov %i0, %o0
4000eb6c: 7f ff f8 40 call 4000cc6c <rtems_bdbuf_add_to_modified_list_after_access>
4000eb70: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000eb74: 7f ff f7 8e call 4000c9ac <rtems_bdbuf_unlock_cache>
4000eb78: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4000eb7c: 81 c7 e0 08 ret
4000eb80: 81 e8 00 00 restore
}
4000eb84: 81 c7 e0 08 ret <== NOT EXECUTED
4000eb88: 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)
4000eb8c: 12 bf ff f3 bne 4000eb58 <rtems_bdbuf_release_modified+0x28><== NEVER TAKEN
4000eb90: 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);
4000eb94: 90 10 00 18 mov %i0, %o0
4000eb98: 7f ff f9 96 call 4000d1f0 <rtems_bdbuf_discard_buffer_after_access>
4000eb9c: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000eba0: 7f ff f7 83 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000eba4: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4000eba8: 81 c7 e0 08 ret
4000ebac: 81 e8 00 00 restore
4000cdd0 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
4000cdd0: 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;
4000cdd4: 35 10 00 6b sethi %hi(0x4001ac00), %i2
4000cdd8: b4 16 a3 34 or %i2, 0x334, %i2 ! 4001af34 <bdbuf_cache>
4000cddc: 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));
4000cde0: 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;
4000cde4: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
4000cde8: 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));
4000cdec: 90 10 00 1b mov %i3, %o0
4000cdf0: 92 10 20 00 clr %o1
4000cdf4: 40 00 1e 7c call 400147e4 <memset>
4000cdf8: 94 10 20 80 mov 0x80, %o2
while (p != NULL)
4000cdfc: 80 a7 60 00 cmp %i5, 0
4000ce00: 02 80 00 11 be 4000ce44 <rtems_bdbuf_remove_from_tree+0x74><== NEVER TAKEN
4000ce04: 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;
4000ce08: 88 10 20 01 mov 1, %g4
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000ce0c: b2 10 3f ff mov -1, %i1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000ce10: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000ce14: fa 20 80 00 st %i5, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000ce18: 80 a0 c0 1c cmp %g3, %i4
4000ce1c: 0a 80 00 65 bcs 4000cfb0 <rtems_bdbuf_remove_from_tree+0x1e0><== NEVER TAKEN
4000ce20: 82 00 a0 04 add %g2, 4, %g1
|| ((p->dd == dd) && (p->block < block)))
4000ce24: 80 a7 00 03 cmp %i4, %g3
4000ce28: 22 80 00 0a be,a 4000ce50 <rtems_bdbuf_remove_from_tree+0x80><== ALWAYS TAKEN
4000ce2c: 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;
4000ce30: f2 2f 60 10 stb %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
p = p->avl.left;
4000ce34: fa 07 60 08 ld [ %i5 + 8 ], %i5
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
4000ce38: 80 a7 60 00 cmp %i5, 0
4000ce3c: 12 bf ff f5 bne 4000ce10 <rtems_bdbuf_remove_from_tree+0x40><== ALWAYS TAKEN
4000ce40: 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);
4000ce44: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
4000ce48: 7f ff fe c9 call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000ce4c: 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)))
4000ce50: 80 a4 00 03 cmp %l0, %g3
4000ce54: 38 80 00 58 bgu,a 4000cfb4 <rtems_bdbuf_remove_from_tree+0x1e4>
4000ce58: c8 2f 60 10 stb %g4, [ %i5 + 0x10 ]
{
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
4000ce5c: 80 a4 00 03 cmp %l0, %g3
4000ce60: 32 bf ff f5 bne,a 4000ce34 <rtems_bdbuf_remove_from_tree+0x64>
4000ce64: f2 2f 60 10 stb %i1, [ %i5 + 0x10 ]
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000ce68: 9a 10 00 01 mov %g1, %o5
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
4000ce6c: 80 a0 80 1b cmp %g2, %i3
4000ce70: 18 80 00 6a bgu 4000d018 <rtems_bdbuf_remove_from_tree+0x248>
4000ce74: 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)
4000ce78: f2 07 60 0c ld [ %i5 + 0xc ], %i1
4000ce7c: 80 a6 60 00 cmp %i1, 0
4000ce80: 22 80 00 6b be,a 4000d02c <rtems_bdbuf_remove_from_tree+0x25c>
4000ce84: c6 07 60 08 ld [ %i5 + 8 ], %g3
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
4000ce88: c6 06 60 08 ld [ %i1 + 8 ], %g3
4000ce8c: 84 10 00 19 mov %i1, %g2
4000ce90: 80 a0 e0 00 cmp %g3, 0
4000ce94: 12 80 00 06 bne 4000ceac <rtems_bdbuf_remove_from_tree+0xdc>
4000ce98: b8 10 3f ff mov -1, %i4
{
r->avl.left = q->avl.left;
4000ce9c: 10 80 00 ba b 4000d184 <rtems_bdbuf_remove_from_tree+0x3b4>
4000cea0: c6 07 60 08 ld [ %i5 + 8 ], %g3
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4000cea4: 84 10 00 03 mov %g3, %g2
4000cea8: 86 10 00 04 mov %g4, %g3
4000ceac: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
*buf_prev++ = r = s;
4000ceb0: c4 20 40 00 st %g2, [ %g1 ]
s = r->avl.left;
r->avl.cache = -1;
4000ceb4: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4000ceb8: 80 a1 20 00 cmp %g4, 0
4000cebc: 12 bf ff fa bne 4000cea4 <rtems_bdbuf_remove_from_tree+0xd4>
4000cec0: 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;
4000cec4: de 07 60 08 ld [ %i5 + 8 ], %o7
r->avl.left = s->avl.right;
4000cec8: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4000cecc: 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;
4000ced0: de 20 e0 08 st %o7, [ %g3 + 8 ]
r->avl.left = s->avl.right;
4000ced4: f8 20 a0 08 st %i4, [ %g2 + 8 ]
s->avl.right = q->avl.right;
4000ced8: f2 20 e0 0c st %i1, [ %g3 + 0xc ]
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
4000cedc: 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;
4000cee0: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
s->avl.cache = 1;
4000cee4: c4 28 e0 10 stb %g2, [ %g3 + 0x10 ]
*t = q = s;
4000cee8: c6 23 7f fc st %g3, [ %o5 + -4 ]
}
}
if (p != NULL)
4000ceec: 80 a6 20 00 cmp %i0, 0
4000cef0: 22 80 00 07 be,a 4000cf0c <rtems_bdbuf_remove_from_tree+0x13c>
4000cef4: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
if (p->avl.cache == -1)
4000cef8: c4 4e 20 10 ldsb [ %i0 + 0x10 ], %g2
4000cefc: 80 a0 bf ff cmp %g2, -1
4000cf00: 22 80 00 03 be,a 4000cf0c <rtems_bdbuf_remove_from_tree+0x13c>
4000cf04: c6 26 20 08 st %g3, [ %i0 + 8 ]
{
p->avl.left = q;
}
else
{
p->avl.right = q;
4000cf08: c6 26 20 0c st %g3, [ %i0 + 0xc ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
4000cf0c: 80 a0 40 1b cmp %g1, %i3
4000cf10: 08 80 00 26 bleu 4000cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000cf14: b2 10 3f ff mov -1, %i1
4000cf18: c4 00 7f fc ld [ %g1 + -4 ], %g2
4000cf1c: c8 08 a0 10 ldub [ %g2 + 0x10 ], %g4
4000cf20: 10 80 00 10 b 4000cf60 <rtems_bdbuf_remove_from_tree+0x190>
4000cf24: 89 29 20 18 sll %g4, 0x18, %g4
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
4000cf28: 86 10 00 02 mov %g2, %g3
modified = false;
4000cf2c: ba 10 20 00 clr %i5
default:
break;
}
}
if (buf_prev > buf_stack)
4000cf30: 80 a0 40 1b cmp %g1, %i3
4000cf34: 28 80 00 1d bleu,a 4000cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000cf38: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
q = *(buf_prev - 1);
4000cf3c: c4 00 7f fc ld [ %g1 + -4 ], %g2
if (q->avl.cache == -1)
4000cf40: c8 08 a0 10 ldub [ %g2 + 0x10 ], %g4
4000cf44: 89 29 20 18 sll %g4, 0x18, %g4
4000cf48: b9 39 20 18 sra %g4, 0x18, %i4
4000cf4c: 80 a7 3f ff cmp %i4, -1
4000cf50: 02 80 00 47 be 4000d06c <rtems_bdbuf_remove_from_tree+0x29c>
4000cf54: 80 8f 60 ff btst 0xff, %i5
*root = q;
}
modified = true;
while (modified)
4000cf58: 02 80 00 14 be 4000cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000cf5c: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
else
{
break;
}
if (p->avl.cache == -1)
4000cf60: 89 39 20 18 sra %g4, 0x18, %g4
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
4000cf64: 82 00 7f fc add %g1, -4, %g1
else
{
break;
}
if (p->avl.cache == -1)
4000cf68: 80 a1 3f ff cmp %g4, -1
4000cf6c: 02 80 00 38 be 4000d04c <rtems_bdbuf_remove_from_tree+0x27c>
4000cf70: c6 48 a0 11 ldsb [ %g2 + 0x11 ], %g3
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4000cf74: 80 a0 e0 00 cmp %g3, 0
4000cf78: 22 bf ff ec be,a 4000cf28 <rtems_bdbuf_remove_from_tree+0x158>
4000cf7c: f2 28 a0 11 stb %i1, [ %g2 + 0x11 ]
4000cf80: 80 a0 e0 01 cmp %g3, 1
4000cf84: 02 80 00 42 be 4000d08c <rtems_bdbuf_remove_from_tree+0x2bc>
4000cf88: 80 a0 ff ff cmp %g3, -1
4000cf8c: 22 80 00 0c be,a 4000cfbc <rtems_bdbuf_remove_from_tree+0x1ec><== ALWAYS TAKEN
4000cf90: c8 00 a0 08 ld [ %g2 + 8 ], %g4
4000cf94: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
default:
break;
}
}
if (buf_prev > buf_stack)
4000cf98: 80 a0 40 1b cmp %g1, %i3 <== NOT EXECUTED
4000cf9c: 18 bf ff e8 bgu 4000cf3c <rtems_bdbuf_remove_from_tree+0x16c><== NOT EXECUTED
4000cfa0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
q->avl.right = p;
}
}
else
{
*root = p;
4000cfa4: c6 26 a0 3c st %g3, [ %i2 + 0x3c ] <== NOT EXECUTED
4000cfa8: 81 c7 e0 08 ret
4000cfac: 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;
4000cfb0: c8 2f 60 10 stb %g4, [ %i5 + 0x10 ] <== NOT EXECUTED
p = p->avl.right;
4000cfb4: 10 bf ff a1 b 4000ce38 <rtems_bdbuf_remove_from_tree+0x68>
4000cfb8: fa 07 60 0c ld [ %i5 + 0xc ], %i5
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
4000cfbc: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
4000cfc0: 80 a0 e0 00 cmp %g3, 0
4000cfc4: 24 80 00 41 ble,a 4000d0c8 <rtems_bdbuf_remove_from_tree+0x2f8>
4000cfc8: fa 01 20 0c ld [ %g4 + 0xc ], %i5
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
4000cfcc: c6 01 20 0c ld [ %g4 + 0xc ], %g3
p1->avl.right = p2->avl.left;
4000cfd0: 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;
4000cfd4: fa 48 e0 11 ldsb [ %g3 + 0x11 ], %i5
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000cfd8: f8 21 20 0c st %i4, [ %g4 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000cfdc: 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;
4000cfe0: c8 20 e0 08 st %g4, [ %g3 + 8 ]
p->avl.left = p2->avl.right;
4000cfe4: 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;
4000cfe8: 80 a7 7f ff cmp %i5, -1
4000cfec: 02 80 00 40 be 4000d0ec <rtems_bdbuf_remove_from_tree+0x31c>
4000cff0: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
4000cff4: c0 28 a0 11 clrb [ %g2 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000cff8: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
4000cffc: 80 a0 a0 01 cmp %g2, 1
4000d000: 22 80 00 42 be,a 4000d108 <rtems_bdbuf_remove_from_tree+0x338>
4000d004: f2 29 20 11 stb %i1, [ %g4 + 0x11 ]
4000d008: c0 29 20 11 clrb [ %g4 + 0x11 ]
p = p2;
p2->avl.bal = 0;
4000d00c: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000d010: 10 bf ff c8 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d014: 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)
4000d018: f2 07 60 0c ld [ %i5 + 0xc ], %i1
4000d01c: 80 a6 60 00 cmp %i1, 0
4000d020: 12 bf ff 9a bne 4000ce88 <rtems_bdbuf_remove_from_tree+0xb8>
4000d024: f0 00 7f f8 ld [ %g1 + -8 ], %i0
{
r = q->avl.left;
4000d028: c6 07 60 08 ld [ %i5 + 8 ], %g3
if (r != NULL)
4000d02c: 80 a0 e0 00 cmp %g3, 0
4000d030: 02 80 00 61 be 4000d1b4 <rtems_bdbuf_remove_from_tree+0x3e4>
4000d034: 80 a6 20 00 cmp %i0, 0
{
r->avl.bal = 0;
4000d038: c0 28 e0 11 clrb [ %g3 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
4000d03c: 12 bf ff af bne 4000cef8 <rtems_bdbuf_remove_from_tree+0x128>
4000d040: 82 10 00 02 mov %g2, %g1
p->avl.right = q;
}
}
else
{
*root = q;
4000d044: 10 bf ff b2 b 4000cf0c <rtems_bdbuf_remove_from_tree+0x13c>
4000d048: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
4000d04c: 80 a0 e0 00 cmp %g3, 0
4000d050: 12 80 00 0b bne 4000d07c <rtems_bdbuf_remove_from_tree+0x2ac>
4000d054: 80 a0 e0 01 cmp %g3, 1
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
4000d058: 88 10 20 01 mov 1, %g4
4000d05c: 86 10 00 02 mov %g2, %g3
4000d060: c8 28 a0 11 stb %g4, [ %g2 + 0x11 ]
modified = false;
4000d064: 10 bf ff b3 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d068: ba 10 20 00 clr %i5
*root = q;
}
modified = true;
while (modified)
4000d06c: 12 bf ff bd bne 4000cf60 <rtems_bdbuf_remove_from_tree+0x190>
4000d070: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000d074: 81 c7 e0 08 ret
4000d078: 81 e8 00 00 restore
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
4000d07c: 02 80 00 08 be 4000d09c <rtems_bdbuf_remove_from_tree+0x2cc>
4000d080: 80 a0 ff ff cmp %g3, -1
4000d084: 32 bf ff c5 bne,a 4000cf98 <rtems_bdbuf_remove_from_tree+0x1c8><== NEVER TAKEN
4000d088: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
4000d08c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000d090: 86 10 00 02 mov %g2, %g3
4000d094: 10 bf ff a7 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d098: ba 10 20 01 mov 1, %i5
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
4000d09c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
if (p1->avl.bal >= 0) /* simple RR-turn */
4000d0a0: fa 48 e0 11 ldsb [ %g3 + 0x11 ], %i5
4000d0a4: 80 a7 60 00 cmp %i5, 0
4000d0a8: 26 80 00 24 bl,a 4000d138 <rtems_bdbuf_remove_from_tree+0x368>
4000d0ac: fa 00 e0 08 ld [ %g3 + 8 ], %i5
{
p->avl.right = p1->avl.left;
4000d0b0: f8 00 e0 08 ld [ %g3 + 8 ], %i4
p1->avl.left = p;
4000d0b4: c4 20 e0 08 st %g2, [ %g3 + 8 ]
if (p1->avl.bal == 0)
4000d0b8: 12 80 00 17 bne 4000d114 <rtems_bdbuf_remove_from_tree+0x344>
4000d0bc: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
{
p1->avl.bal = -1;
4000d0c0: 10 bf ff 9c b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d0c4: 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;
4000d0c8: c4 21 20 0c st %g2, [ %g4 + 0xc ]
if (p1->avl.bal == 0)
4000d0cc: 80 a0 e0 00 cmp %g3, 0
4000d0d0: 12 80 00 15 bne 4000d124 <rtems_bdbuf_remove_from_tree+0x354>
4000d0d4: fa 20 a0 08 st %i5, [ %g2 + 8 ]
{
p1->avl.bal = 1;
4000d0d8: 84 10 20 01 mov 1, %g2
4000d0dc: 86 10 00 04 mov %g4, %g3
4000d0e0: c4 29 20 11 stb %g2, [ %g4 + 0x11 ]
modified = false;
4000d0e4: 10 bf ff 93 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d0e8: 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;
4000d0ec: ba 10 20 01 mov 1, %i5
4000d0f0: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000d0f4: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
4000d0f8: 80 a0 a0 01 cmp %g2, 1
4000d0fc: 32 bf ff c4 bne,a 4000d00c <rtems_bdbuf_remove_from_tree+0x23c><== ALWAYS TAKEN
4000d100: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000d104: f2 29 20 11 stb %i1, [ %g4 + 0x11 ] <== NOT EXECUTED
p = p2;
p2->avl.bal = 0;
4000d108: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000d10c: 10 bf ff 89 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d110: ba 10 20 01 mov 1, %i5
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
4000d114: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p1->avl.bal = 0;
4000d118: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000d11c: 10 bf ff 85 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d120: ba 10 20 01 mov 1, %i5
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
4000d124: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p1->avl.bal = 0;
4000d128: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000d12c: 86 10 00 04 mov %g4, %g3
4000d130: 10 bf ff 80 b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d134: ba 10 20 01 mov 1, %i5
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000d138: 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;
4000d13c: f8 4f 60 11 ldsb [ %i5 + 0x11 ], %i4
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000d140: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000d144: 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;
4000d148: c6 27 60 0c st %g3, [ %i5 + 0xc ]
p->avl.right = p2->avl.left;
4000d14c: 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;
4000d150: 80 a7 20 01 cmp %i4, 1
4000d154: 02 80 00 16 be 4000d1ac <rtems_bdbuf_remove_from_tree+0x3dc>
4000d158: c4 27 60 08 st %g2, [ %i5 + 8 ]
4000d15c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000d160: c4 4f 60 11 ldsb [ %i5 + 0x11 ], %g2
4000d164: 80 a0 bf ff cmp %g2, -1
4000d168: 02 80 00 0f be 4000d1a4 <rtems_bdbuf_remove_from_tree+0x3d4><== NEVER TAKEN
4000d16c: 84 10 20 01 mov 1, %g2
4000d170: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p = p2;
p2->avl.bal = 0;
4000d174: c0 2f 60 11 clrb [ %i5 + 0x11 ]
4000d178: 86 10 00 1d mov %i5, %g3
4000d17c: 10 bf ff 6d b 4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d180: 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;
4000d184: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4000d188: c6 26 60 08 st %g3, [ %i1 + 8 ]
r->avl.bal = q->avl.bal;
4000d18c: c4 2e 60 11 stb %g2, [ %i1 + 0x11 ]
r->avl.cache = 1;
*buf_prev++ = q = r;
4000d190: 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;
4000d194: 84 10 20 01 mov 1, %g2
*buf_prev++ = q = r;
4000d198: 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;
4000d19c: 10 bf ff 54 b 4000ceec <rtems_bdbuf_remove_from_tree+0x11c>
4000d1a0: 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;
4000d1a4: 10 bf ff f4 b 4000d174 <rtems_bdbuf_remove_from_tree+0x3a4><== NOT EXECUTED
4000d1a8: 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;
4000d1ac: 10 bf ff ed b 4000d160 <rtems_bdbuf_remove_from_tree+0x390>
4000d1b0: 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)
4000d1b4: 10 bf ff 4e b 4000ceec <rtems_bdbuf_remove_from_tree+0x11c>
4000d1b8: 82 10 00 02 mov %g2, %g1
4000d248 <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)
{
4000d248: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
4000d24c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000d250: 80 a2 20 00 cmp %o0, 0
4000d254: 22 80 00 0a be,a 4000d27c <rtems_bdbuf_remove_from_tree_and_lru_list+0x34>
4000d258: c4 06 00 00 ld [ %i0 ], %g2
4000d25c: 80 a2 20 02 cmp %o0, 2
4000d260: 02 80 00 04 be 4000d270 <rtems_bdbuf_remove_from_tree_and_lru_list+0x28><== ALWAYS TAKEN
4000d264: 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);
4000d268: 7f ff fd c1 call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000d26c: 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);
4000d270: 7f ff fe d8 call 4000cdd0 <rtems_bdbuf_remove_from_tree>
4000d274: 90 10 00 18 mov %i0, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000d278: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
4000d27c: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
4000d280: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000d284: c4 20 40 00 st %g2, [ %g1 ]
4000d288: 81 c7 e0 08 ret
4000d28c: 81 e8 00 00 restore
4000ca30 <rtems_bdbuf_restore_preemption>:
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000ca30: 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);
4000ca34: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000ca38: 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);
4000ca3c: 90 10 00 18 mov %i0, %o0
4000ca40: 94 07 a0 44 add %fp, 0x44, %o2
4000ca44: 40 00 12 3e call 4001133c <rtems_task_mode>
4000ca48: 92 12 63 ff or %o1, 0x3ff, %o1
if (sc != RTEMS_SUCCESSFUL)
4000ca4c: 80 a2 20 00 cmp %o0, 0
4000ca50: 12 80 00 04 bne 4000ca60 <rtems_bdbuf_restore_preemption+0x30><== NEVER TAKEN
4000ca54: 01 00 00 00 nop
4000ca58: 81 c7 e0 08 ret
4000ca5c: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
4000ca60: 7f ff ff ab call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000ca64: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED
4000ef4c <rtems_bdbuf_set_block_size>:
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
4000ef4c: 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)
4000ef50: 80 a6 a0 00 cmp %i2, 0
4000ef54: 12 80 00 43 bne 4000f060 <rtems_bdbuf_set_block_size+0x114>
4000ef58: 01 00 00 00 nop
rtems_bdbuf_syncdev (dd);
rtems_bdbuf_lock_cache ();
4000ef5c: 7f ff f6 7e call 4000c954 <rtems_bdbuf_lock_cache>
4000ef60: b8 10 20 0a mov 0xa, %i4 ! a <PROM_START+0xa>
if (block_size > 0)
4000ef64: 80 a6 60 00 cmp %i1, 0
4000ef68: 12 80 00 06 bne 4000ef80 <rtems_bdbuf_set_block_size+0x34>
4000ef6c: 03 10 00 65 sethi %hi(0x40019400), %g1
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
4000ef70: 7f ff f6 8f call 4000c9ac <rtems_bdbuf_unlock_cache>
4000ef74: b0 10 00 1c mov %i4, %i0
return sc;
}
4000ef78: 81 c7 e0 08 ret
4000ef7c: 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)
4000ef80: 82 10 62 08 or %g1, 0x208, %g1
4000ef84: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
4000ef88: 80 a6 40 02 cmp %i1, %g2
4000ef8c: 18 bf ff f9 bgu 4000ef70 <rtems_bdbuf_set_block_size+0x24><== NEVER TAKEN
4000ef90: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
4000ef94: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
4000ef98: 40 00 21 28 call 40017438 <.udiv>
4000ef9c: 90 06 7f ff add %i1, -1, %o0
4000efa0: 90 02 20 01 inc %o0
for (bds_per_size = 1;
4000efa4: 80 a2 20 01 cmp %o0, 1
4000efa8: 08 80 00 06 bleu 4000efc0 <rtems_bdbuf_set_block_size+0x74>
4000efac: 92 10 20 01 mov 1, %o1
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
4000efb0: 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;
4000efb4: 80 a2 00 09 cmp %o0, %o1
4000efb8: 38 bf ff ff bgu,a 4000efb4 <rtems_bdbuf_set_block_size+0x68>
4000efbc: 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;
4000efc0: 03 10 00 6b sethi %hi(0x4001ac00), %g1
4000efc4: d0 00 63 54 ld [ %g1 + 0x354 ], %o0 ! 4001af54 <bdbuf_cache+0x20>
4000efc8: 40 00 21 1c call 40017438 <.udiv>
4000efcc: 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)
4000efd0: 80 a2 20 00 cmp %o0, 0
4000efd4: 02 bf ff e7 be 4000ef70 <rtems_bdbuf_set_block_size+0x24> <== NEVER TAKEN
4000efd8: 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;
4000efdc: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
4000efe0: 90 10 00 19 mov %i1, %o0
4000efe4: 92 10 00 1c mov %i4, %o1
4000efe8: 40 00 21 14 call 40017438 <.udiv>
4000efec: ba 10 20 00 clr %i5
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
4000eff0: 80 a2 20 01 cmp %o0, 1
4000eff4: 08 80 00 08 bleu 4000f014 <rtems_bdbuf_set_block_size+0xc8>
4000eff8: b6 10 00 08 mov %o0, %i3
4000effc: 84 10 20 01 mov 1, %g2
{
++block_to_media_block_shift;
4000f000: 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)
4000f004: 83 28 80 1d sll %g2, %i5, %g1
4000f008: 80 a6 c0 01 cmp %i3, %g1
4000f00c: 38 bf ff fe bgu,a 4000f004 <rtems_bdbuf_set_block_size+0xb8>
4000f010: ba 07 60 01 inc %i5
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
4000f014: b9 2f 00 1d sll %i4, %i5, %i4
4000f018: 80 a7 00 19 cmp %i4, %i1
4000f01c: 32 80 00 02 bne,a 4000f024 <rtems_bdbuf_set_block_size+0xd8><== NEVER TAKEN
4000f020: 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;
4000f024: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
4000f028: 92 10 00 1b mov %i3, %o1
4000f02c: 40 00 21 03 call 40017438 <.udiv>
4000f030: f2 26 20 24 st %i1, [ %i0 + 0x24 ]
4000f034: 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);
4000f038: 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;
4000f03c: f6 26 20 2c st %i3, [ %i0 + 0x2c ]
dd->block_to_media_block_shift = block_to_media_block_shift;
4000f040: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
dd->bds_per_group = bds_per_group;
4000f044: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
rtems_bdbuf_purge_dev (dd);
4000f048: 7f ff ff 43 call 4000ed54 <rtems_bdbuf_purge_dev>
4000f04c: b8 10 20 00 clr %i4
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
4000f050: 7f ff f6 57 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000f054: b0 10 00 1c mov %i4, %i0
return sc;
}
4000f058: 81 c7 e0 08 ret
4000f05c: 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);
4000f060: 7f ff ff 26 call 4000ecf8 <rtems_bdbuf_syncdev>
4000f064: 90 10 00 18 mov %i0, %o0
4000f068: 30 bf ff bd b,a 4000ef5c <rtems_bdbuf_set_block_size+0x10>
4000c788 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
4000c788: 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;
4000c78c: 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 );
4000c790: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
4000c794: 80 a0 40 19 cmp %g1, %i1
4000c798: 02 80 00 2e be 4000c850 <rtems_bdbuf_swapout_modified_processing+0xc8>
4000c79c: 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))
4000c7a0: 12 80 00 57 bne 4000c8fc <rtems_bdbuf_swapout_modified_processing+0x174>
4000c7a4: 9e 10 20 00 clr %o7
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
4000c7a8: 05 10 00 6b sethi %hi(0x4001ac00), %g2
4000c7ac: d8 00 a3 a8 ld [ %g2 + 0x3a8 ], %o4 ! 4001afa8 <bdbuf_cache+0x74>
4000c7b0: 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;
4000c7b4: 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))
4000c7b8: 80 a3 e0 00 cmp %o7, 0
4000c7bc: 32 80 00 3b bne,a 4000c8a8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000c7c0: c4 06 00 00 ld [ %i0 ], %g2
4000c7c4: 80 a6 e0 00 cmp %i3, 0
4000c7c8: 02 80 00 07 be 4000c7e4 <rtems_bdbuf_swapout_modified_processing+0x5c>
4000c7cc: 80 a3 20 00 cmp %o4, 0
4000c7d0: c4 06 00 00 ld [ %i0 ], %g2
4000c7d4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
4000c7d8: 80 a0 80 03 cmp %g2, %g3
4000c7dc: 02 80 00 34 be 4000c8ac <rtems_bdbuf_swapout_modified_processing+0x124>
4000c7e0: 80 a3 20 00 cmp %o4, 0
|| rtems_bdbuf_has_buffer_waiters ())
4000c7e4: 32 80 00 31 bne,a 4000c8a8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000c7e8: c4 06 00 00 ld [ %i0 ], %g2
bd->hold_timer = 0;
if (bd->hold_timer)
4000c7ec: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000c7f0: 80 a0 a0 00 cmp %g2, 0
4000c7f4: 02 80 00 0b be 4000c820 <rtems_bdbuf_swapout_modified_processing+0x98><== NEVER TAKEN
4000c7f8: 80 a7 20 00 cmp %i4, 0
{
if (update_timers)
4000c7fc: 22 80 00 12 be,a 4000c844 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000c800: c2 00 40 00 ld [ %g1 ], %g1
{
if (bd->hold_timer > timer_delta)
4000c804: 80 a0 80 1d cmp %g2, %i5
4000c808: 28 80 00 3a bleu,a 4000c8f0 <rtems_bdbuf_swapout_modified_processing+0x168>
4000c80c: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
4000c810: 84 20 80 1d sub %g2, %i5, %g2
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
4000c814: 80 a0 a0 00 cmp %g2, 0
4000c818: 12 80 00 0a bne 4000c840 <rtems_bdbuf_swapout_modified_processing+0xb8><== ALWAYS TAKEN
4000c81c: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
4000c820: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
4000c824: 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)
4000c828: 80 a0 a0 00 cmp %g2, 0
4000c82c: 22 80 00 24 be,a 4000c8bc <rtems_bdbuf_swapout_modified_processing+0x134>
4000c830: 84 10 00 03 mov %g3, %g2
*dd_ptr = bd->dd;
if (bd->dd == *dd_ptr)
4000c834: 80 a0 c0 02 cmp %g3, %g2
4000c838: 22 80 00 08 be,a 4000c858 <rtems_bdbuf_swapout_modified_processing+0xd0><== ALWAYS TAKEN
4000c83c: c4 00 60 04 ld [ %g1 + 4 ], %g2
node = next_node;
}
else
{
node = node->next;
4000c840: 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))
4000c844: 80 a0 40 19 cmp %g1, %i1
4000c848: 12 bf ff dd bne 4000c7bc <rtems_bdbuf_swapout_modified_processing+0x34>
4000c84c: 80 a3 e0 00 cmp %o7, 0
4000c850: 81 c7 e0 08 ret
4000c854: 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;
4000c858: 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;
4000c85c: 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;
4000c860: c4 23 60 04 st %g2, [ %o5 + 4 ]
previous->next = next;
4000c864: da 20 80 00 st %o5, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
4000c868: c4 06 a0 08 ld [ %i2 + 8 ], %g2
while (node && !rtems_chain_is_head (transfer, tnode))
4000c86c: 80 a0 80 1a cmp %g2, %i2
4000c870: 22 80 00 1a be,a 4000c8d8 <rtems_bdbuf_swapout_modified_processing+0x150>
4000c874: c4 06 80 00 ld [ %i2 ], %g2
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
4000c878: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4000c87c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4000c880: 80 a1 00 03 cmp %g4, %g3
4000c884: 28 80 00 11 bleu,a 4000c8c8 <rtems_bdbuf_swapout_modified_processing+0x140>
4000c888: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000c88c: c6 00 80 00 ld [ %g2 ], %g3
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000c890: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000c894: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
4000c898: c6 20 40 00 st %g3, [ %g1 ]
before_node->previous = the_node;
4000c89c: c2 20 e0 04 st %g1, [ %g3 + 4 ]
4000c8a0: 10 bf ff e9 b 4000c844 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000c8a4: 82 10 00 0d mov %o5, %g1
4000c8a8: 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)
4000c8ac: 80 a0 a0 00 cmp %g2, 0
4000c8b0: 12 bf ff e1 bne 4000c834 <rtems_bdbuf_swapout_modified_processing+0xac>
4000c8b4: c0 20 60 2c clr [ %g1 + 0x2c ]
*dd_ptr = bd->dd;
4000c8b8: 84 10 00 03 mov %g3, %g2
4000c8bc: c6 26 00 00 st %g3, [ %i0 ]
4000c8c0: 10 bf ff dd b 4000c834 <rtems_bdbuf_swapout_modified_processing+0xac>
4000c8c4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
4000c8c8: 80 a0 80 1a cmp %g2, %i2
4000c8cc: 32 bf ff ec bne,a 4000c87c <rtems_bdbuf_swapout_modified_processing+0xf4>
4000c8d0: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000c8d4: c4 06 80 00 ld [ %i2 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000c8d8: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000c8dc: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
4000c8e0: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
4000c8e4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000c8e8: 10 bf ff d7 b 4000c844 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000c8ec: 82 10 00 0d mov %o5, %g1
4000c8f0: c4 06 00 00 ld [ %i0 ], %g2
4000c8f4: 10 bf ff cd b 4000c828 <rtems_bdbuf_swapout_modified_processing+0xa0>
4000c8f8: 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))
4000c8fc: c4 06 00 00 ld [ %i0 ], %g2
4000c900: 80 a0 00 02 cmp %g0, %g2
4000c904: 10 bf ff a9 b 4000c7a8 <rtems_bdbuf_swapout_modified_processing+0x20>
4000c908: 9e 60 3f ff subx %g0, -1, %o7
4000dca4 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
4000dca4: 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;
4000dca8: 23 10 00 65 sethi %hi(0x40019400), %l1
4000dcac: a2 14 62 08 or %l1, 0x208, %l1 ! 40019608 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000dcb0: 7f ff fb b2 call 4000cb78 <rtems_bdbuf_swapout_writereq_alloc>
4000dcb4: 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);
4000dcb8: 03 10 00 65 sethi %hi(0x40019400), %g1
4000dcbc: d2 00 61 cc ld [ %g1 + 0x1cc ], %o1 ! 400195cc <Configuration+0xc>
4000dcc0: 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 ();
4000dcc4: 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;
4000dcc8: b4 07 bf e8 add %fp, -24, %i2
4000dccc: b0 07 bf ec add %fp, -20, %i0
head->previous = NULL;
4000dcd0: c0 27 bf ec clr [ %fp + -20 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000dcd4: f0 27 bf e8 st %i0, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
4000dcd8: f4 27 bf f0 st %i2, [ %fp + -16 ]
rtems_chain_initialize_empty (&transfer.bds);
transfer.dd = BDBUF_INVALID_DEV;
4000dcdc: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
4000dce0: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000dce4: 91 2e e0 07 sll %i3, 7, %o0
4000dce8: 90 22 00 01 sub %o0, %g1, %o0
4000dcec: 90 02 00 1b add %o0, %i3, %o0
4000dcf0: 40 00 25 d2 call 40017438 <.udiv>
4000dcf4: 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 ();
4000dcf8: 7f ff fb 17 call 4000c954 <rtems_bdbuf_lock_cache>
4000dcfc: ac 10 00 08 mov %o0, %l6
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000dd00: 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)
4000dd04: 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++)
4000dd08: 80 a0 60 00 cmp %g1, 0
4000dd0c: 02 80 00 c3 be 4000e018 <rtems_bdbuf_swapout_task+0x374> <== ALWAYS TAKEN
4000dd10: 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;
4000dd14: 21 10 00 6b sethi %hi(0x4001ac00), %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),
4000dd18: 29 10 91 1b sethi %hi(0x42446c00), %l4 <== NOT EXECUTED
4000dd1c: a0 14 23 34 or %l0, 0x334, %l0 <== NOT EXECUTED
4000dd20: 27 10 00 38 sethi %hi(0x4000e000), %l3 <== NOT EXECUTED
the_node->next = tail;
4000dd24: 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;
4000dd28: 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),
4000dd2c: a8 15 23 00 or %l4, 0x300, %l4 <== NOT EXECUTED
4000dd30: a6 14 e0 38 or %l3, 0x38, %l3 <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4000dd34: 7f ff da 0f call 40004570 <malloc> <== NOT EXECUTED
4000dd38: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
4000dd3c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4000dd40: 02 80 00 bb be 4000e02c <rtems_bdbuf_swapout_task+0x388> <== NOT EXECUTED
4000dd44: 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;
4000dd48: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED
the_node->next = tail;
4000dd4c: ee 27 40 00 st %l7, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
4000dd50: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000dd54: 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;
4000dd58: 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 ();
4000dd5c: 7f ff fb 87 call 4000cb78 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
4000dd60: 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),
4000dd64: 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 );
4000dd68: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
4000dd6c: 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 ();
4000dd70: 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),
4000dd74: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
4000dd78: 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;
4000dd7c: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
4000dd80: 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;
4000dd84: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000dd88: 90 16 40 14 or %i1, %l4, %o0 <== NOT EXECUTED
4000dd8c: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4000dd90: 98 07 60 08 add %i5, 8, %o4 <== NOT EXECUTED
4000dd94: 7f ff fb f7 call 4000cd70 <rtems_bdbuf_create_task.constprop.9><== NOT EXECUTED
4000dd98: 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)
4000dd9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dda0: 12 80 00 a1 bne 4000e024 <rtems_bdbuf_swapout_task+0x380> <== NOT EXECUTED
4000dda4: 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++)
4000dda8: 80 a6 40 12 cmp %i1, %l2 <== NOT EXECUTED
4000ddac: 12 bf ff e2 bne 4000dd34 <rtems_bdbuf_swapout_task+0x90> <== NOT EXECUTED
4000ddb0: 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 ();
4000ddb4: 7f ff fa fe call 4000c9ac <rtems_bdbuf_unlock_cache>
4000ddb8: 01 00 00 00 nop
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000ddbc: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000ddc0: 80 a0 60 00 cmp %g1, 0
4000ddc4: 02 80 00 75 be 4000df98 <rtems_bdbuf_swapout_task+0x2f4> <== NEVER TAKEN
4000ddc8: 82 07 20 08 add %i4, 8, %g1
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000ddcc: 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,
4000ddd0: 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))
4000ddd4: a8 07 20 0c add %i4, 0xc, %l4
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000ddd8: 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;
4000dddc: 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)
4000dde0: 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;
4000dde4: 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 ();
4000dde8: 7f ff fa db call 4000c954 <rtems_bdbuf_lock_cache>
4000ddec: 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)
4000ddf0: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
4000ddf4: 80 a0 60 00 cmp %g1, 0
4000ddf8: 32 80 00 2f bne,a 4000deb4 <rtems_bdbuf_swapout_task+0x210>
4000ddfc: 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;
4000de00: 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))
4000de04: 80 a4 c0 14 cmp %l3, %l4
4000de08: 02 80 00 7b be 4000dff4 <rtems_bdbuf_swapout_task+0x350> <== ALWAYS TAKEN
4000de0c: 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;
4000de10: 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;
4000de14: ba 04 e0 10 add %l3, 0x10, %i5 <== NOT EXECUTED
head->next = new_first;
4000de18: c4 27 20 08 st %g2, [ %i4 + 8 ] <== NOT EXECUTED
new_first->previous = head;
4000de1c: 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 );
4000de20: 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,
4000de24: a4 07 60 0c add %i5, 0xc, %l2
4000de28: 96 10 20 01 mov 1, %o3
4000de2c: 98 10 20 00 clr %o4
4000de30: 9a 10 00 1b mov %i3, %o5
4000de34: 90 10 00 12 mov %l2, %o0
4000de38: 94 10 00 1d mov %i5, %o2
head->next = tail;
4000de3c: ee 27 40 00 st %l7, [ %i5 ]
head->previous = NULL;
4000de40: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
4000de44: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
4000de48: c0 27 60 0c clr [ %i5 + 0xc ]
transfer->syncing = bdbuf_cache.sync_active;
4000de4c: 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,
4000de50: 13 10 00 6b sethi %hi(0x4001ac00), %o1
4000de54: 7f ff fa 4d call 4000c788 <rtems_bdbuf_swapout_modified_processing>
4000de58: 92 12 63 8c or %o1, 0x38c, %o1 ! 4001af8c <bdbuf_cache+0x58>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000de5c: d2 07 bf dc ld [ %fp + -36 ], %o1
4000de60: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
4000de64: 90 10 00 12 mov %l2, %o0
4000de68: 94 10 00 1d mov %i5, %o2
4000de6c: 98 0e 60 01 and %i1, 1, %o4
4000de70: 7f ff fa 46 call 4000c788 <rtems_bdbuf_swapout_modified_processing>
4000de74: 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 ();
4000de78: 7f ff fa cd call 4000c9ac <rtems_bdbuf_unlock_cache>
4000de7c: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000de80: c6 07 40 00 ld [ %i5 ], %g3
4000de84: 80 a0 c0 17 cmp %g3, %l7
4000de88: 02 80 00 28 be 4000df28 <rtems_bdbuf_swapout_task+0x284>
4000de8c: 80 a4 e0 00 cmp %l3, 0
{
if (worker)
4000de90: 02 80 00 22 be 4000df18 <rtems_bdbuf_swapout_task+0x274> <== ALWAYS TAKEN
4000de94: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
4000de98: d0 04 e0 08 ld [ %l3 + 8 ], %o0 <== NOT EXECUTED
4000de9c: 7f ff e8 b2 call 40008164 <rtems_event_send> <== NOT EXECUTED
4000dea0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000dea4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dea8: 12 80 00 56 bne 4000e000 <rtems_bdbuf_swapout_task+0x35c> <== NOT EXECUTED
4000deac: b2 10 20 00 clr %i1 <== NOT EXECUTED
4000deb0: 30 bf ff ce b,a 4000dde8 <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,
4000deb4: 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;
4000deb8: 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,
4000debc: 98 10 20 00 clr %o4
4000dec0: 9a 10 00 1b mov %i3, %o5
4000dec4: 90 07 bf f4 add %fp, -12, %o0
4000dec8: 92 10 00 15 mov %l5, %o1
4000decc: 94 10 00 1a mov %i2, %o2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000ded0: f0 27 bf e8 st %i0, [ %fp + -24 ]
head->previous = NULL;
4000ded4: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
4000ded8: f4 27 bf f0 st %i2, [ %fp + -16 ]
4000dedc: 7f ff fa 2b call 4000c788 <rtems_bdbuf_swapout_modified_processing>
4000dee0: e0 2f bf f8 stb %l0, [ %fp + -8 ]
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000dee4: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
4000dee8: 90 07 bf f4 add %fp, -12, %o0
4000deec: 92 10 00 11 mov %l1, %o1
4000def0: 94 10 00 1a mov %i2, %o2
4000def4: 98 0e 60 01 and %i1, 1, %o4
4000def8: 7f ff fa 24 call 4000c788 <rtems_bdbuf_swapout_modified_processing>
4000defc: 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 ();
4000df00: 7f ff fa ab call 4000c9ac <rtems_bdbuf_unlock_cache>
4000df04: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000df08: c2 07 bf e8 ld [ %fp + -24 ], %g1
4000df0c: 80 a0 40 18 cmp %g1, %i0
4000df10: 02 80 00 06 be 4000df28 <rtems_bdbuf_swapout_task+0x284>
4000df14: 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);
4000df18: 7f ff ff 09 call 4000db3c <rtems_bdbuf_swapout_write>
4000df1c: 90 10 00 1d mov %i5, %o0
4000df20: 10 bf ff b2 b 4000dde8 <rtems_bdbuf_swapout_task+0x144>
4000df24: b2 10 20 00 clr %i1
}
transfered_buffers = true;
}
if (bdbuf_cache.sync_active && !transfered_buffers)
4000df28: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
4000df2c: 80 a0 60 00 cmp %g1, 0
4000df30: 02 80 00 0f be 4000df6c <rtems_bdbuf_swapout_task+0x2c8>
4000df34: 90 10 20 04 mov 4, %o0
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
4000df38: 7f ff fa 87 call 4000c954 <rtems_bdbuf_lock_cache>
4000df3c: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
4000df40: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
4000df44: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
4000df48: 7f ff fa 99 call 4000c9ac <rtems_bdbuf_unlock_cache>
4000df4c: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
4000df50: 80 a7 60 00 cmp %i5, 0
4000df54: 02 80 00 06 be 4000df6c <rtems_bdbuf_swapout_task+0x2c8> <== NEVER TAKEN
4000df58: 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 );
4000df5c: 90 10 00 1d mov %i5, %o0
4000df60: 7f ff ea 34 call 40008830 <rtems_event_system_send>
4000df64: 13 20 00 00 sethi %hi(0x80000000), %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4000df68: 90 10 20 04 mov 4, %o0
4000df6c: 92 10 20 00 clr %o1
4000df70: 94 10 00 16 mov %l6, %o2
4000df74: 7f ff e8 18 call 40007fd4 <rtems_event_receive>
4000df78: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4000df7c: 80 a2 20 06 cmp %o0, 6
4000df80: 12 80 00 22 bne 4000e008 <rtems_bdbuf_swapout_task+0x364>
4000df84: 80 a2 20 00 cmp %o0, 0
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000df88: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000df8c: 80 a0 60 00 cmp %g1, 0
4000df90: 12 bf ff 95 bne 4000dde4 <rtems_bdbuf_swapout_task+0x140> <== ALWAYS TAKEN
4000df94: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
4000df98: 7f ff fa 6f call 4000c954 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000df9c: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000dfa0: 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))
4000dfa4: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
4000dfa8: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000dfac: 02 80 00 0a be 4000dfd4 <rtems_bdbuf_swapout_task+0x330> <== NOT EXECUTED
4000dfb0: 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);
4000dfb4: 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;
4000dfb8: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4000dfbc: 7f ff e8 6a call 40008164 <rtems_event_send> <== NOT EXECUTED
4000dfc0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000dfc4: 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))
4000dfc8: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000dfcc: 32 bf ff fb bne,a 4000dfb8 <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
4000dfd0: 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 ();
4000dfd4: 7f ff fa 76 call 4000c9ac <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000dfd8: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
4000dfdc: 7f ff d8 1d call 40004050 <free> <== NOT EXECUTED
4000dfe0: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000dfe4: 7f ff ea 71 call 400089a8 <rtems_task_delete> <== NOT EXECUTED
4000dfe8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000dfec: 81 c7 e0 08 ret <== NOT EXECUTED
4000dff0: 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))
4000dff4: 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,
4000dff8: 10 bf ff 8a b 4000de20 <rtems_bdbuf_swapout_task+0x17c>
4000dffc: 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);
4000e000: 7f ff fa 43 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e004: 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))
4000e008: 22 bf ff e1 be,a 4000df8c <rtems_bdbuf_swapout_task+0x2e8><== ALWAYS TAKEN
4000e00c: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
4000e010: 7f ff fa 3f call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e014: 90 10 20 18 mov 0x18, %o0 <== NOT EXECUTED
4000e018: 39 10 00 6b sethi %hi(0x4001ac00), %i4
4000e01c: 10 bf ff 66 b 4000ddb4 <rtems_bdbuf_swapout_task+0x110>
4000e020: b8 17 23 34 or %i4, 0x334, %i4 ! 4001af34 <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);
4000e024: 7f ff fa 3a call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e028: 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);
4000e02c: 7f ff fa 38 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e030: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
4000e038 <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)
{
4000e038: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4000e03c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
4000e040: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000e044: 02 80 00 1b be 4000e0b0 <rtems_bdbuf_swapout_worker_task+0x78><== NOT EXECUTED
4000e048: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
4000e04c: 39 10 00 6b sethi %hi(0x4001ac00), %i4 <== NOT EXECUTED
4000e050: b6 06 20 10 add %i0, 0x10, %i3 <== NOT EXECUTED
4000e054: b8 17 23 34 or %i4, 0x334, %i4 <== NOT EXECUTED
4000e058: b2 06 20 14 add %i0, 0x14, %i1 <== NOT EXECUTED
4000e05c: b4 07 20 0c add %i4, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4000e060: 7f ff fa b4 call 4000cb30 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
4000e064: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4000e068: 7f ff fe b5 call 4000db3c <rtems_bdbuf_swapout_write> <== NOT EXECUTED
4000e06c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4000e070: 7f ff fa 39 call 4000c954 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000e074: 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;
4000e078: 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;
4000e07c: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000e080: 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;
4000e084: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
4000e088: fa 27 20 10 st %i5, [ %i4 + 0x10 ] <== NOT EXECUTED
old_last->next = the_node;
4000e08c: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000e090: 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;
4000e094: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4000e098: 7f ff fa 45 call 4000c9ac <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000e09c: 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)
4000e0a0: c2 0f 60 0c ldub [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4000e0a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000e0a8: 12 bf ff ee bne 4000e060 <rtems_bdbuf_swapout_worker_task+0x28><== NOT EXECUTED
4000e0ac: 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);
4000e0b0: d0 07 60 24 ld [ %i5 + 0x24 ], %o0 <== NOT EXECUTED
4000e0b4: 7f ff d7 e7 call 40004050 <free> <== NOT EXECUTED
4000e0b8: b0 10 20 00 clr %i0 <== NOT EXECUTED
free (worker);
4000e0bc: 7f ff d7 e5 call 40004050 <free> <== NOT EXECUTED
4000e0c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000e0c4: 7f ff ea 39 call 400089a8 <rtems_task_delete> <== NOT EXECUTED
4000e0c8: 81 e8 00 00 restore <== NOT EXECUTED
4000db3c <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
4000db3c: 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;
4000db40: 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 );
4000db44: 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))
4000db48: 80 a0 40 1d cmp %g1, %i5
4000db4c: 02 80 00 4f be 4000dc88 <rtems_bdbuf_swapout_write+0x14c> <== NEVER TAKEN
4000db50: 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;
4000db54: 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;
4000db58: 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;
4000db5c: 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;
4000db60: f4 04 20 2c ld [ %l0 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000db64: 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;
4000db68: 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;
4000db6c: 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;
4000db70: c4 22 60 0c st %g2, [ %o1 + 0xc ]
transfer->write_req->bufnum = 0;
4000db74: 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;
4000db78: 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))
4000db7c: 10 80 00 23 b 4000dc08 <rtems_bdbuf_swapout_write+0xcc>
4000db80: 25 10 00 65 sethi %hi(0x40019400), %l2
4000db84: 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];
4000db88: 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;
4000db8c: 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;
4000db90: 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++;
4000db94: b8 01 20 01 add %g4, 1, %i4
4000db98: 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];
4000db9c: 89 29 20 04 sll %g4, 4, %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000dba0: b8 10 00 03 mov %g3, %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000dba4: 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;
4000dba8: 9a 10 20 00 clr %o5
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000dbac: 86 02 40 04 add %o1, %g4, %g3
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000dbb0: 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;
4000dbb4: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
4000dbb8: de 20 e0 04 st %o7, [ %g3 + 4 ]
buf->buffer = bd->buffer;
4000dbbc: f2 20 e0 08 st %i1, [ %g3 + 8 ]
4000dbc0: 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) ||
4000dbc4: 80 a7 40 01 cmp %i5, %g1
4000dbc8: 02 80 00 07 be 4000dbe4 <rtems_bdbuf_swapout_write+0xa8>
4000dbcc: 84 14 a2 08 or %l2, 0x208, %g2
4000dbd0: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
4000dbd4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000dbd8: 80 a0 c0 02 cmp %g3, %g2
4000dbdc: 0a 80 00 1e bcs 4000dc54 <rtems_bdbuf_swapout_write+0x118>
4000dbe0: 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);
4000dbe4: 90 10 00 10 mov %l0, %o0
4000dbe8: 7f ff ff 5d call 4000d95c <rtems_bdbuf_execute_transfer_request>
4000dbec: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000dbf0: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
4000dbf4: c2 06 00 00 ld [ %i0 ], %g1
4000dbf8: 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))
4000dbfc: 80 a7 40 01 cmp %i5, %g1
4000dc00: 02 80 00 19 be 4000dc64 <rtems_bdbuf_swapout_write+0x128>
4000dc04: 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;
4000dc08: 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 &&
4000dc0c: 80 a4 60 00 cmp %l1, 0
head->next = new_first;
4000dc10: c4 26 00 00 st %g2, [ %i0 ]
4000dc14: 02 bf ff dc be 4000db84 <rtems_bdbuf_swapout_write+0x48>
4000dc18: f0 20 a0 04 st %i0, [ %g2 + 4 ]
4000dc1c: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
4000dc20: 80 a0 e0 00 cmp %g3, 0
4000dc24: 02 bf ff d9 be 4000db88 <rtems_bdbuf_swapout_write+0x4c>
4000dc28: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
4000dc2c: 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 &&
4000dc30: 80 a0 c0 04 cmp %g3, %g4
4000dc34: 02 bf ff d5 be 4000db88 <rtems_bdbuf_swapout_write+0x4c>
4000dc38: 9a 10 20 01 mov 1, %o5
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000dc3c: f0 20 60 04 st %i0, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000dc40: c2 26 00 00 st %g1, [ %i0 ]
the_node->next = before_node;
4000dc44: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
4000dc48: 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;
4000dc4c: 10 bf ff de b 4000dbc4 <rtems_bdbuf_swapout_write+0x88>
4000dc50: 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)
4000dc54: 12 bf ff e4 bne 4000dbe4 <rtems_bdbuf_swapout_write+0xa8>
4000dc58: 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))
4000dc5c: 32 bf ff ec bne,a 4000dc0c <rtems_bdbuf_swapout_write+0xd0><== ALWAYS TAKEN
4000dc60: 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 &&
4000dc64: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
4000dc68: 80 a0 60 00 cmp %g1, 0
4000dc6c: 02 80 00 0c be 4000dc9c <rtems_bdbuf_swapout_write+0x160>
4000dc70: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
4000dc74: d0 04 20 08 ld [ %l0 + 8 ], %o0
4000dc78: 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 &&
4000dc7c: 80 88 60 02 btst 2, %g1
4000dc80: 32 80 00 04 bne,a 4000dc90 <rtems_bdbuf_swapout_write+0x154><== NEVER TAKEN
4000dc84: c2 04 20 38 ld [ %l0 + 0x38 ], %g1 <== NOT EXECUTED
4000dc88: 81 c7 e0 08 ret
4000dc8c: 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);
4000dc90: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000dc94: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000dc98: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000dc9c: 81 c7 e0 08 ret
4000dca0: 81 e8 00 00 restore
4000cb78 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4000cb78: 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)));
4000cb7c: 03 10 00 65 sethi %hi(0x40019400), %g1
4000cb80: d0 00 62 0c ld [ %g1 + 0x20c ], %o0 ! 4001960c <rtems_bdbuf_configuration+0x4>
4000cb84: 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 =
4000cb88: 7f ff de 7a call 40004570 <malloc>
4000cb8c: 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)
4000cb90: ba 92 20 00 orcc %o0, 0, %i5
4000cb94: 02 80 00 0b be 4000cbc0 <rtems_bdbuf_swapout_writereq_alloc+0x48><== NEVER TAKEN
4000cb98: 82 10 20 01 mov 1, %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
4000cb9c: c2 27 40 00 st %g1, [ %i5 ]
write_req->done = rtems_bdbuf_transfer_done;
4000cba0: 03 10 00 38 sethi %hi(0x4000e000), %g1
4000cba4: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 4000e1a0 <rtems_bdbuf_transfer_done>
write_req->io_task = rtems_task_self ();
return write_req;
}
4000cba8: 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 ();
4000cbac: 40 00 12 50 call 400114ec <rtems_task_self>
4000cbb0: c2 27 60 04 st %g1, [ %i5 + 4 ]
4000cbb4: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
return write_req;
}
4000cbb8: 81 c7 e0 08 ret
4000cbbc: 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);
4000cbc0: 7f ff ff 53 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000cbc4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
4000ebb0 <rtems_bdbuf_sync>:
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
4000ebb0: 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)
4000ebb4: 80 a6 20 00 cmp %i0, 0
4000ebb8: 02 80 00 30 be 4000ec78 <rtems_bdbuf_sync+0xc8> <== NEVER TAKEN
4000ebbc: 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();
4000ebc0: 7f ff f7 65 call 4000c954 <rtems_bdbuf_lock_cache>
4000ebc4: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4000ebc8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000ebcc: 80 a2 20 03 cmp %o0, 3
4000ebd0: 1a 80 00 04 bcc 4000ebe0 <rtems_bdbuf_sync+0x30> <== ALWAYS TAKEN
4000ebd4: 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);
4000ebd8: 7f ff f7 65 call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000ebdc: 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)
4000ebe0: 08 80 00 0b bleu 4000ec0c <rtems_bdbuf_sync+0x5c>
4000ebe4: 82 10 20 08 mov 8, %g1
4000ebe8: 80 a2 20 06 cmp %o0, 6
4000ebec: 12 bf ff fb bne 4000ebd8 <rtems_bdbuf_sync+0x28> <== NEVER TAKEN
4000ebf0: 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);
4000ebf4: 7f ff f9 7f call 4000d1f0 <rtems_bdbuf_discard_buffer_after_access>
4000ebf8: 90 10 00 18 mov %i0, %o0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4000ebfc: 7f ff f7 6c call 4000c9ac <rtems_bdbuf_unlock_cache>
4000ec00: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000ec04: 81 c7 e0 08 ret
4000ec08: 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;
4000ec0c: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ec10: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
4000ec14: ba 17 63 34 or %i5, 0x334, %i5
4000ec18: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
the_node->next = tail;
4000ec1c: 84 07 60 5c add %i5, 0x5c, %g2
tail->previous = the_node;
4000ec20: 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;
4000ec24: 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)
4000ec28: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
4000ec2c: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000ec30: 80 a0 a0 00 cmp %g2, 0
4000ec34: 12 80 00 13 bne 4000ec80 <rtems_bdbuf_sync+0xd0>
4000ec38: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
4000ec3c: 7f ff f7 62 call 4000c9c4 <rtems_bdbuf_wake_swapper>
4000ec40: 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);
4000ec44: 13 10 00 6b sethi %hi(0x4001ac00), %o1
4000ec48: b8 12 63 a0 or %o1, 0x3a0, %i4 ! 4001afa0 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000ec4c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000ec50: 80 a2 20 01 cmp %o0, 1
4000ec54: 0a 80 00 07 bcs 4000ec70 <rtems_bdbuf_sync+0xc0> <== NEVER TAKEN
4000ec58: 80 a2 20 07 cmp %o0, 7
4000ec5c: 28 80 00 10 bleu,a 4000ec9c <rtems_bdbuf_sync+0xec>
4000ec60: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000ec64: 80 a2 20 0a cmp %o0, 0xa
4000ec68: 28 80 00 09 bleu,a 4000ec8c <rtems_bdbuf_sync+0xdc> <== ALWAYS TAKEN
4000ec6c: 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);
4000ec70: 7f ff f7 3f call 4000c96c <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000ec74: 92 10 20 15 mov 0x15, %o1 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
4000ec78: 81 c7 e0 08 ret <== NOT EXECUTED
4000ec7c: 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);
4000ec80: 7f ff f7 ec call 4000cc30 <rtems_bdbuf_wake>
4000ec84: 90 07 60 64 add %i5, 0x64, %o0
4000ec88: 30 bf ff ed b,a 4000ec3c <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);
4000ec8c: 7f ff f7 96 call 4000cae4 <rtems_bdbuf_wait>
4000ec90: 92 10 00 1c mov %i4, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000ec94: 10 bf ff ef b 4000ec50 <rtems_bdbuf_sync+0xa0>
4000ec98: 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
4000ec9c: 80 a0 60 00 cmp %g1, 0
4000eca0: 12 bf ff d7 bne 4000ebfc <rtems_bdbuf_sync+0x4c>
4000eca4: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
4000eca8: 80 a0 60 01 cmp %g1, 1
4000ecac: 18 bf ff d4 bgu 4000ebfc <rtems_bdbuf_sync+0x4c> <== NEVER TAKEN
4000ecb0: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
4000ecb4: 02 80 00 06 be 4000eccc <rtems_bdbuf_sync+0x11c>
4000ecb8: 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);
4000ecbc: 11 10 00 6b sethi %hi(0x4001ac00), %o0
4000ecc0: 7f ff f7 dc call 4000cc30 <rtems_bdbuf_wake>
4000ecc4: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 4001afa8 <bdbuf_cache+0x74>
4000ecc8: 30 bf ff cd b,a 4000ebfc <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);
4000eccc: 7f ff f8 41 call 4000cdd0 <rtems_bdbuf_remove_from_tree>
4000ecd0: 90 10 00 18 mov %i0, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000ecd4: 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;
4000ecd8: c0 26 20 20 clr [ %i0 + 0x20 ]
after_node->next = the_node;
4000ecdc: f0 27 60 40 st %i0, [ %i5 + 0x40 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000ece0: 05 10 00 6b sethi %hi(0x4001ac00), %g2
4000ece4: 84 10 a3 74 or %g2, 0x374, %g2 ! 4001af74 <bdbuf_cache+0x40>
4000ece8: c4 26 20 04 st %g2, [ %i0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
4000ecec: c2 26 00 00 st %g1, [ %i0 ]
before_node->previous = the_node;
4000ecf0: 10 bf ff f3 b 4000ecbc <rtems_bdbuf_sync+0x10c>
4000ecf4: f0 20 60 04 st %i0, [ %g1 + 4 ]
4000c980 <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)
{
4000c980: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
4000c984: 7f ff ef 80 call 40008784 <rtems_semaphore_release>
4000c988: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
4000c98c: 80 a2 20 00 cmp %o0, 0
4000c990: 12 80 00 04 bne 4000c9a0 <rtems_bdbuf_unlock+0x20> <== NEVER TAKEN
4000c994: 01 00 00 00 nop
4000c998: 81 c7 e0 08 ret
4000c99c: 81 e8 00 00 restore
rtems_bdbuf_fatal (fatal_error_code);
4000c9a0: 7f ff ff db call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c9a4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000cb30 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4000cb30: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
4000cb34: 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;
4000cb38: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
4000cb3c: 90 10 00 18 mov %i0, %o0
4000cb40: 94 10 20 00 clr %o2
4000cb44: 7f ff ed 24 call 40007fd4 <rtems_event_receive>
4000cb48: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
4000cb4c: 80 a2 20 00 cmp %o0, 0
4000cb50: 12 80 00 07 bne 4000cb6c <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000cb54: c2 07 bf fc ld [ %fp + -4 ], %g1
4000cb58: 80 a0 40 18 cmp %g1, %i0
4000cb5c: 12 80 00 04 bne 4000cb6c <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000cb60: 01 00 00 00 nop
4000cb64: 81 c7 e0 08 ret
4000cb68: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
4000cb6c: 7f ff ff 68 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000cb70: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
4000d924 <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
4000d924: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
4000d928: 11 20 00 00 sethi %hi(0x80000000), %o0
4000d92c: 92 10 20 00 clr %o1
4000d930: 94 10 20 00 clr %o2
4000d934: 40 00 0e 5f call 400112b0 <rtems_event_system_receive>
4000d938: 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)
4000d93c: 80 a2 20 00 cmp %o0, 0
4000d940: 12 80 00 04 bne 4000d950 <rtems_bdbuf_wait_for_transient_event+0x2c><== NEVER TAKEN
4000d944: 01 00 00 00 nop
4000d948: 81 c7 e0 08 ret
4000d94c: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
4000d950: 7f ff fb ef call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000d954: 90 10 20 1d mov 0x1d, %o0 <== NOT EXECUTED
4000cc30 <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)
{
4000cc30: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
4000cc34: c2 06 00 00 ld [ %i0 ], %g1
4000cc38: 80 a0 60 00 cmp %g1, 0
4000cc3c: 12 80 00 04 bne 4000cc4c <rtems_bdbuf_wake+0x1c>
4000cc40: 01 00 00 00 nop
4000cc44: 81 c7 e0 08 ret
4000cc48: 81 e8 00 00 restore
{
sc = rtems_semaphore_flush (waiters->sema);
4000cc4c: 40 00 11 6c call 400111fc <rtems_semaphore_flush>
4000cc50: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4000cc54: 80 a2 20 00 cmp %o0, 0
4000cc58: 02 bf ff fb be 4000cc44 <rtems_bdbuf_wake+0x14> <== ALWAYS TAKEN
4000cc5c: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
4000cc60: 7f ff ff 2b call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000cc64: 90 10 20 04 mov 4, %o0 ! 4 <PROM_START+0x4> <== NOT EXECUTED
4000c9c4 <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
4000c9c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4000c9c8: 03 10 00 6b sethi %hi(0x4001ac00), %g1
4000c9cc: d0 00 63 34 ld [ %g1 + 0x334 ], %o0 ! 4001af34 <bdbuf_cache>
4000c9d0: 7f ff ed e5 call 40008164 <rtems_event_send>
4000c9d4: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000c9d8: 80 a2 20 00 cmp %o0, 0
4000c9dc: 12 80 00 04 bne 4000c9ec <rtems_bdbuf_wake_swapper+0x28> <== NEVER TAKEN
4000c9e0: 01 00 00 00 nop
4000c9e4: 81 c7 e0 08 ret
4000c9e8: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
4000c9ec: 7f ff ff c8 call 4000c90c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000c9f0: 90 10 20 0b mov 0xb, %o0 <== NOT EXECUTED
4000281c <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
4000281c: 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;
40002820: 80 a6 60 00 cmp %i1, 0
40002824: 02 80 00 06 be 4000283c <rtems_bdpart_create+0x20> <== NEVER TAKEN
40002828: 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
4000282c: c2 06 40 00 ld [ %i1 ], %g1
40002830: 80 a0 60 00 cmp %g1, 0
40002834: 22 80 00 12 be,a 4000287c <rtems_bdpart_create+0x60> <== ALWAYS TAKEN
40002838: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
4000283c: 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
40002840: 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 =
40002844: 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) {
40002848: 80 a7 20 00 cmp %i4, 0
4000284c: 02 80 00 0a be 40002874 <rtems_bdpart_create+0x58> <== NEVER TAKEN
40002850: b0 10 20 00 clr %i0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
40002854: 80 a6 a0 00 cmp %i2, 0
40002858: 02 80 00 07 be 40002874 <rtems_bdpart_create+0x58> <== NEVER TAKEN
4000285c: b0 10 20 09 mov 9, %i0
40002860: 80 a6 60 00 cmp %i1, 0
40002864: 02 80 00 04 be 40002874 <rtems_bdpart_create+0x58> <== NEVER TAKEN
40002868: 80 a6 e0 00 cmp %i3, 0
4000286c: 12 80 00 0a bne 40002894 <rtems_bdpart_create+0x78> <== ALWAYS TAKEN
40002870: 92 10 20 00 clr %o1
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
40002874: 81 c7 e0 08 ret <== NOT EXECUTED
40002878: 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;
4000287c: 80 a0 60 00 cmp %g1, 0
40002880: 02 bf ff f0 be 40002840 <rtems_bdpart_create+0x24> <== NEVER TAKEN
40002884: c0 27 bf fc clr [ %fp + -4 ]
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
40002888: 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 =
4000288c: 10 bf ff ef b 40002848 <rtems_bdpart_create+0x2c>
40002890: 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);
40002894: 94 10 20 00 clr %o2
40002898: 40 00 01 3d call 40002d8c <rtems_bdpart_get_disk_data>
4000289c: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
400028a0: b0 92 20 00 orcc %o0, 0, %i0
400028a4: 12 80 00 72 bne 40002a6c <rtems_bdpart_create+0x250> <== NEVER TAKEN
400028a8: 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];
400028ac: e4 06 c0 00 ld [ %i3 ], %l2
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
400028b0: ba 94 a0 00 orcc %l2, 0, %i5
400028b4: 12 80 00 0b bne 400028e0 <rtems_bdpart_create+0xc4> <== ALWAYS TAKEN
400028b8: 82 10 20 00 clr %g1
return RTEMS_INVALID_NUMBER;
400028bc: 81 c7 e0 08 ret <== NOT EXECUTED
400028c0: 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];
400028c4: c4 06 c0 02 ld [ %i3 + %g2 ], %g2
400028c8: 86 07 40 02 add %i5, %g2, %g3
if (dist_sum < prev_sum) {
400028cc: 80 a0 c0 1d cmp %g3, %i5
400028d0: 0a 80 00 0e bcs 40002908 <rtems_bdpart_create+0xec> <== NEVER TAKEN
400028d4: 80 a0 a0 00 cmp %g2, 0
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
400028d8: 02 80 00 0c be 40002908 <rtems_bdpart_create+0xec> <== NEVER TAKEN
400028dc: 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) {
400028e0: 82 00 60 01 inc %g1
400028e4: 80 a0 40 1c cmp %g1, %i4
400028e8: 12 bf ff f7 bne 400028c4 <rtems_bdpart_create+0xa8>
400028ec: 85 28 60 02 sll %g1, 2, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
400028f0: c2 06 40 00 ld [ %i1 ], %g1
400028f4: 80 a0 60 00 cmp %g1, 0
400028f8: 02 80 00 06 be 40002910 <rtems_bdpart_create+0xf4> <== ALWAYS TAKEN
400028fc: a2 8c 60 ff andcc %l1, 0xff, %l1
return RTEMS_NOT_IMPLEMENTED;
40002900: 81 c7 e0 08 ret <== NOT EXECUTED
40002904: 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;
40002908: 81 c7 e0 08 ret <== NOT EXECUTED
4000290c: 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) {
40002910: 02 80 00 06 be 40002928 <rtems_bdpart_create+0x10c> <== NEVER TAKEN
40002914: ec 07 bf fc ld [ %fp + -4 ], %l6
disk_end -= (disk_end % record_space);
40002918: 90 10 00 16 mov %l6, %o0
4000291c: 40 00 7d 79 call 40021f00 <.urem>
40002920: 92 10 00 10 mov %l0, %o1
40002924: 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) {
40002928: 80 a7 20 04 cmp %i4, 4
4000292c: 08 80 00 06 bleu 40002944 <rtems_bdpart_create+0x128> <== NEVER TAKEN
40002930: aa 10 00 10 mov %l0, %l5
overhead += (count - 3) * record_space;
40002934: 90 10 00 10 mov %l0, %o0
40002938: 40 00 7c 8c call 40021b68 <.umul>
4000293c: 92 07 3f fd add %i4, -3, %o1
40002940: aa 02 00 10 add %o0, %l0, %l5
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
40002944: 80 a4 60 00 cmp %l1, 0
40002948: 02 80 00 07 be 40002964 <rtems_bdpart_create+0x148> <== NEVER TAKEN
4000294c: 82 05 40 1c add %l5, %i4, %g1
overhead += (count - 1) * record_space;
40002950: 90 10 00 10 mov %l0, %o0
40002954: 40 00 7c 85 call 40021b68 <.umul>
40002958: 92 07 3f ff add %i4, -1, %o1
4000295c: aa 05 40 08 add %l5, %o0, %l5
}
/* Check disk space */
if ((overhead + count) > disk_end) {
40002960: 82 05 40 1c add %l5, %i4, %g1
40002964: 80 a0 40 16 cmp %g1, %l6
40002968: 08 80 00 04 bleu 40002978 <rtems_bdpart_create+0x15c> <== ALWAYS TAKEN
4000296c: aa 25 80 15 sub %l6, %l5, %l5
return RTEMS_IO_ERROR;
40002970: 81 c7 e0 08 ret <== NOT EXECUTED
40002974: 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];
40002978: 92 10 00 12 mov %l2, %o1
4000297c: 40 00 7c 7b call 40021b68 <.umul>
40002980: 90 10 00 15 mov %l5, %o0
if (s < free_space || s < dist [i]) {
40002984: 80 a5 40 08 cmp %l5, %o0
40002988: 18 bf ff e0 bgu 40002908 <rtems_bdpart_create+0xec> <== NEVER TAKEN
4000298c: 80 a4 80 08 cmp %l2, %o0
40002990: 18 bf ff de bgu 40002908 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40002994: 80 a7 20 04 cmp %i4, 4
40002998: 18 80 00 03 bgu 400029a4 <rtems_bdpart_create+0x188> <== ALWAYS TAKEN
4000299c: ae 10 20 01 mov 1, %l7
400029a0: ae 10 20 00 clr %l7 <== NOT EXECUTED
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
400029a4: a8 06 a0 30 add %i2, 0x30, %l4
400029a8: a6 10 00 1a mov %i2, %l3
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
400029ac: a2 10 00 10 mov %l0, %l1
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
400029b0: 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) {
400029b4: 10 80 00 0b b 400029e0 <rtems_bdpart_create+0x1c4>
400029b8: 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];
400029bc: 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;
400029c0: a6 10 00 14 mov %l4, %l3
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
400029c4: 40 00 7c 69 call 40021b68 <.umul>
400029c8: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
400029cc: 80 a5 40 08 cmp %l5, %o0
400029d0: 18 bf ff ce bgu 40002908 <rtems_bdpart_create+0xec> <== NEVER TAKEN
400029d4: 80 a4 80 08 cmp %l2, %o0
400029d8: 18 bf ff cc bgu 40002908 <rtems_bdpart_create+0xec> <== NEVER TAKEN
400029dc: a8 05 20 30 add %l4, 0x30, %l4
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
400029e0: 40 00 7c 9c call 40021c50 <.udiv>
400029e4: 92 10 00 1d mov %i5, %o1
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
400029e8: 92 10 00 10 mov %l0, %o1
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
/* Ensure that the partition is not empty */
if (s == 0) {
400029ec: 80 a2 20 00 cmp %o0, 0
400029f0: 12 80 00 03 bne 400029fc <rtems_bdpart_create+0x1e0> <== ALWAYS TAKEN
400029f4: a4 10 00 08 mov %o0, %l2
s = 1;
400029f8: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
}
/* Align partition upwards */
s += record_space - (s % record_space);
400029fc: 40 00 7d 41 call 40021f00 <.urem>
40002a00: 90 10 00 12 mov %l2, %o0
40002a04: 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];
40002a08: 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) {
40002a0c: 82 10 20 01 mov 1, %g1
40002a10: 80 a6 60 02 cmp %i1, 2
40002a14: 18 80 00 03 bgu 40002a20 <rtems_bdpart_create+0x204>
40002a18: 90 24 80 08 sub %l2, %o0, %o0
40002a1c: 82 10 20 00 clr %g1
40002a20: 80 88 60 ff btst 0xff, %g1
40002a24: 22 80 00 06 be,a 40002a3c <rtems_bdpart_create+0x220>
40002a28: e2 24 c0 00 st %l1, [ %l3 ]
40002a2c: 80 a5 e0 00 cmp %l7, 0
40002a30: 32 80 00 02 bne,a 40002a38 <rtems_bdpart_create+0x21c> <== ALWAYS TAKEN
40002a34: a2 04 40 10 add %l1, %l0, %l1
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
40002a38: e2 24 c0 00 st %l1, [ %l3 ]
pos += s;
40002a3c: a2 04 40 08 add %l1, %o0, %l1
p->end = pos;
40002a40: 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) {
40002a44: b2 06 60 01 inc %i1
40002a48: 80 a7 00 19 cmp %i4, %i1
40002a4c: 18 bf ff dc bgu 400029bc <rtems_bdpart_create+0x1a0>
40002a50: 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;
40002a54: b8 07 3f ff add %i4, -1, %i4
40002a58: 83 2f 20 04 sll %i4, 4, %g1
40002a5c: b9 2f 20 06 sll %i4, 6, %i4
40002a60: 82 27 00 01 sub %i4, %g1, %g1
40002a64: b4 06 80 01 add %i2, %g1, %i2
40002a68: ec 26 a0 04 st %l6, [ %i2 + 4 ]
40002a6c: 81 c7 e0 08 ret
40002a70: 81 e8 00 00 restore
40002a74 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
40002a74: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
40002a78: 11 10 00 95 sethi %hi(0x40025400), %o0
40002a7c: 40 00 4d 7b call 40016068 <puts>
40002a80: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400254d0 <__FUNCTION__.6193+0x298>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002a84: 80 a6 60 00 cmp %i1, 0
40002a88: 02 80 00 3a be 40002b70 <rtems_bdpart_dump+0xfc> <== NEVER TAKEN
40002a8c: 11 10 00 95 sethi %hi(0x40025400), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002a90: 29 10 00 95 sethi %hi(0x40025400), %l4
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40002a94: 37 10 00 95 sethi %hi(0x40025400), %i3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002a98: 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";
40002a9c: 2b 10 00 95 sethi %hi(0x40025400), %l5
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002aa0: a8 15 22 10 or %l4, 0x210, %l4
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
40002aa4: 27 10 00 95 sethi %hi(0x40025400), %l3
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
40002aa8: 25 10 00 95 sethi %hi(0x40025400), %l2
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
40002aac: 23 10 00 95 sethi %hi(0x40025400), %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";
40002ab0: 21 10 00 95 sethi %hi(0x40025400), %l0
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
40002ab4: 35 10 00 95 sethi %hi(0x40025400), %i2
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40002ab8: 10 80 00 19 b 40002b1c <rtems_bdpart_dump+0xa8>
40002abc: b6 16 e2 18 or %i3, 0x218, %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) {
40002ac0: 80 a2 e0 0b cmp %o3, 0xb
40002ac4: 22 80 00 0e be,a 40002afc <rtems_bdpart_dump+0x88> <== ALWAYS TAKEN
40002ac8: 96 15 60 b8 or %l5, 0xb8, %o3
40002acc: 18 80 00 2d bgu 40002b80 <rtems_bdpart_dump+0x10c> <== NOT EXECUTED
40002ad0: 80 a2 e0 0e cmp %o3, 0xe <== NOT EXECUTED
40002ad4: 80 a2 e0 01 cmp %o3, 1 <== NOT EXECUTED
40002ad8: 02 80 00 36 be 40002bb0 <rtems_bdpart_dump+0x13c> <== NOT EXECUTED
40002adc: 80 a2 e0 04 cmp %o3, 4 <== NOT EXECUTED
40002ae0: 22 80 00 07 be,a 40002afc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40002ae4: 96 16 a0 90 or %i2, 0x90, %o3 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002ae8: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
40002aec: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
40002af0: 40 00 4d 98 call 40016150 <snprintf> <== NOT EXECUTED
40002af4: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
type = type_buffer;
40002af8: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40002afc: d2 06 00 00 ld [ %i0 ], %o1
40002b00: d4 06 20 04 ld [ %i0 + 4 ], %o2
40002b04: 40 00 4d 23 call 40015f90 <printf>
40002b08: 90 10 00 1b mov %i3, %o0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002b0c: ba 07 60 01 inc %i5
40002b10: 80 a7 40 19 cmp %i5, %i1
40002b14: 02 80 00 16 be 40002b6c <rtems_bdpart_dump+0xf8>
40002b18: 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;
40002b1c: c0 2f bf c7 clrb [ %fp + -57 ]
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
40002b20: b8 06 20 08 add %i0, 8, %i4
40002b24: 92 07 bf c7 add %fp, -57, %o1
40002b28: 40 00 00 8d call 40002d5c <rtems_bdpart_to_mbr_partition_type>
40002b2c: 90 10 00 1c mov %i4, %o0
40002b30: 80 8a 20 ff btst 0xff, %o0
40002b34: 12 bf ff e3 bne 40002ac0 <rtems_bdpart_dump+0x4c> <== ALWAYS TAKEN
40002b38: 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);
40002b3c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40002b40: 40 00 2c ca call 4000de68 <uuid_unparse_lower> <== NOT EXECUTED
40002b44: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40002b48: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
40002b4c: 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;
40002b50: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
}
printf(
40002b54: 40 00 4d 0f call 40015f90 <printf> <== NOT EXECUTED
40002b58: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40002b5c: ba 07 60 01 inc %i5 <== NOT EXECUTED
40002b60: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED
40002b64: 12 bf ff ee bne 40002b1c <rtems_bdpart_dump+0xa8> <== NOT EXECUTED
40002b68: b0 06 20 30 add %i0, 0x30, %i0 <== NOT EXECUTED
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
40002b6c: 11 10 00 95 sethi %hi(0x40025400), %o0
40002b70: 40 00 4d 3e call 40016068 <puts>
40002b74: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 400255c0 <__FUNCTION__.6193+0x388>
40002b78: 81 c7 e0 08 ret
40002b7c: 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) {
40002b80: 02 80 00 0a be 40002ba8 <rtems_bdpart_dump+0x134> <== NOT EXECUTED
40002b84: 80 a2 e0 da cmp %o3, 0xda <== NOT EXECUTED
40002b88: 02 80 00 06 be 40002ba0 <rtems_bdpart_dump+0x12c> <== NOT EXECUTED
40002b8c: 80 a2 e0 0c cmp %o3, 0xc <== NOT EXECUTED
40002b90: 12 bf ff d7 bne 40002aec <rtems_bdpart_dump+0x78> <== NOT EXECUTED
40002b94: 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;
40002b98: 10 bf ff d9 b 40002afc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40002b9c: 96 14 60 a8 or %l1, 0xa8, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
40002ba0: 10 bf ff d7 b 40002afc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40002ba4: 96 14 a0 a0 or %l2, 0xa0, %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;
40002ba8: 10 bf ff d5 b 40002afc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40002bac: 96 14 e0 c0 or %l3, 0xc0, %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";
40002bb0: 10 bf ff d3 b 40002afc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40002bb4: 96 14 20 98 or %l0, 0x98, %o3 <== NOT EXECUTED
40002d8c <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
40002d8c: 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);
40002d90: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
40002d94: 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);
40002d98: 40 00 0d 2a call 40006240 <open>
40002d9c: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
40002da0: ba 92 20 00 orcc %o0, 0, %i5
40002da4: 16 80 00 07 bge 40002dc0 <rtems_bdpart_get_disk_data+0x34><== ALWAYS TAKEN
40002da8: 94 07 bf fc add %fp, -4, %o2
sc = RTEMS_INVALID_NAME;
40002dac: 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);
40002db0: 40 00 09 50 call 400052f0 <close> <== NOT EXECUTED
40002db4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40002db8: 81 c7 e0 08 ret <== NOT EXECUTED
40002dbc: 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);
40002dc0: 13 10 01 10 sethi %hi(0x40044000), %o1
40002dc4: 40 00 09 ed call 40005578 <ioctl>
40002dc8: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x1c519>
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
40002dcc: 80 a2 20 00 cmp %o0, 0
40002dd0: 32 bf ff f8 bne,a 40002db0 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40002dd4: 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;
40002dd8: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
40002ddc: 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;
40002de0: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
*disk_end = dd->size;
40002de4: c4 26 c0 00 st %g2, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
40002de8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40002dec: 80 a0 a1 ff cmp %g2, 0x1ff
40002df0: 08 bf ff f0 bleu 40002db0 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40002df4: 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) {
40002df8: 80 a0 e0 00 cmp %g3, 0
40002dfc: 12 bf ff ed bne 40002db0 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40002e00: 80 a6 60 00 cmp %i1, 0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
40002e04: 02 80 00 08 be 40002e24 <rtems_bdpart_get_disk_data+0x98>
40002e08: 80 a6 a0 00 cmp %i2, 0
40002e0c: 02 80 00 07 be 40002e28 <rtems_bdpart_get_disk_data+0x9c> <== NEVER TAKEN
40002e10: b0 10 20 00 clr %i0
*fd_ptr = fd;
40002e14: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
40002e18: c2 26 80 00 st %g1, [ %i2 ]
40002e1c: 81 c7 e0 08 ret
40002e20: 81 e8 00 00 restore
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
40002e24: 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);
40002e28: 40 00 09 32 call 400052f0 <close>
40002e2c: 90 10 00 1d mov %i5, %o0
40002e30: 81 c7 e0 08 ret
40002e34: 81 e8 00 00 restore
40023e40 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40023e40: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
40023e44: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
40023e48: 40 00 7d b9 call 4004352c <strrchr> <== NOT EXECUTED
40023e4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40023e50: 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);
40023e54: 40 00 79 93 call 400424a0 <strlen> <== NOT EXECUTED
40023e58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40023e5c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
40023e60: 40 00 79 90 call 400424a0 <strlen> <== NOT EXECUTED
40023e64: 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
)
{
40023e68: 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);
40023e6c: 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;
40023e70: 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);
40023e74: 7f ff 7c 21 call 40002ef8 <malloc> <== NOT EXECUTED
40023e78: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
40023e7c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40023e80: 02 80 00 4f be 40023fbc <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
40023e84: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
40023e88: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40023e8c: 40 00 7a 41 call 40042790 <strncpy> <== NOT EXECUTED
40023e90: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
40023e94: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40023e98: 02 80 00 06 be 40023eb0 <rtems_bdpart_mount+0x70> <== NOT EXECUTED
40023e9c: a6 10 00 10 mov %l0, %l3 <== NOT EXECUTED
disk_file_name += 1;
40023ea0: ba 07 20 01 add %i4, 1, %i5 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
40023ea4: 40 00 79 7f call 400424a0 <strlen> <== NOT EXECUTED
40023ea8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40023eac: 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);
40023eb0: a4 04 c0 11 add %l3, %l1, %l2 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
40023eb4: 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);
40023eb8: 7f ff 7c 10 call 40002ef8 <malloc> <== NOT EXECUTED
40023ebc: 90 04 a0 05 add %l2, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
40023ec0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40023ec4: 02 80 00 3a be 40023fac <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
40023ec8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
40023ecc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40023ed0: 40 00 7a 30 call 40042790 <strncpy> <== NOT EXECUTED
40023ed4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
40023ed8: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40023edc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40023ee0: 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] = '/';
40023ee4: c2 2f 00 11 stb %g1, [ %i4 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40023ee8: 90 07 00 08 add %i4, %o0, %o0 <== NOT EXECUTED
40023eec: 40 00 7a 29 call 40042790 <strncpy> <== NOT EXECUTED
40023ef0: 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;
40023ef4: 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;
40023ef8: 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) {
40023efc: ba 10 20 00 clr %i5 <== NOT EXECUTED
40023f00: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40023f04: 02 80 00 29 be 40023fa8 <rtems_bdpart_mount+0x168> <== NOT EXECUTED
40023f08: 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);
40023f0c: 21 10 01 81 sethi %hi(0x40060400), %l0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
40023f10: 23 10 01 7a sethi %hi(0x4005e800), %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);
40023f14: a0 14 23 08 or %l0, 0x308, %l0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
40023f18: 10 80 00 04 b 40023f28 <rtems_bdpart_mount+0xe8> <== NOT EXECUTED
40023f1c: a2 14 60 28 or %l1, 0x28, %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) {
40023f20: 22 80 00 23 be,a 40023fac <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
40023f24: 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);
40023f28: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40023f2c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40023f30: ba 07 60 01 inc %i5 <== NOT EXECUTED
40023f34: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40023f38: 40 00 75 e2 call 400416c0 <snprintf> <== NOT EXECUTED
40023f3c: 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);
40023f40: 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) {
40023f44: 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);
40023f48: 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) {
40023f4c: 14 80 00 1e bg 40023fc4 <rtems_bdpart_mount+0x184> <== NOT EXECUTED
40023f50: 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);
40023f54: 40 00 7a 0f call 40042790 <strncpy> <== NOT EXECUTED
40023f58: 01 00 00 00 nop <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
40023f5c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40023f60: 40 00 10 17 call 40027fbc <rtems_mkdir> <== NOT EXECUTED
40023f64: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
40023f68: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40023f6c: 12 80 00 1c bne 40023fdc <rtems_bdpart_mount+0x19c> <== NOT EXECUTED
40023f70: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
40023f74: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40023f78: 96 10 20 00 clr %o3 <== NOT EXECUTED
40023f7c: 98 10 20 00 clr %o4 <== NOT EXECUTED
40023f80: 7f ff 7c 64 call 40003110 <mount> <== NOT EXECUTED
40023f84: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
40023f88: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40023f8c: 02 bf ff e5 be 40023f20 <rtems_bdpart_mount+0xe0> <== NOT EXECUTED
40023f90: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
rmdir( mount_point);
40023f94: 40 00 0f de call 40027f0c <rmdir> <== NOT EXECUTED
40023f98: 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) {
40023f9c: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
40023fa0: 12 bf ff e3 bne 40023f2c <rtems_bdpart_mount+0xec> <== NOT EXECUTED
40023fa4: 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;
40023fa8: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
40023fac: 7f ff 7a f9 call 40002b90 <free> <== NOT EXECUTED
40023fb0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
40023fb4: 7f ff 7a f7 call 40002b90 <free> <== NOT EXECUTED
40023fb8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
40023fbc: 81 c7 e0 08 ret <== NOT EXECUTED
40023fc0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
40023fc4: 7f ff 7a f3 call 40002b90 <free> <== NOT EXECUTED
40023fc8: 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;
40023fcc: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
40023fd0: 7f ff 7a f0 call 40002b90 <free> <== NOT EXECUTED
40023fd4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40023fd8: 30 bf ff f9 b,a 40023fbc <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
40023fdc: 7f ff 7a ed call 40002b90 <free> <== NOT EXECUTED
40023fe0: 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;
40023fe4: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
40023fe8: 7f ff 7a ea call 40002b90 <free> <== NOT EXECUTED
40023fec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40023ff0: 30 bf ff f3 b,a 40023fbc <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
400032ac <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
400032ac: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
400032b0: d0 06 80 00 ld [ %i2 ], %o0
400032b4: 80 a2 20 00 cmp %o0, 0
400032b8: 22 80 00 07 be,a 400032d4 <rtems_bdpart_new_record+0x28>
400032bc: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_sync( *block);
400032c0: 40 00 34 24 call 40010350 <rtems_bdbuf_sync>
400032c4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400032c8: ba 92 20 00 orcc %o0, 0, %i5
400032cc: 12 80 00 17 bne 40003328 <rtems_bdpart_new_record+0x7c> <== NEVER TAKEN
400032d0: 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);
400032d4: 92 10 00 19 mov %i1, %o1
400032d8: 40 00 33 41 call 4000ffdc <rtems_bdbuf_read>
400032dc: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
400032e0: ba 92 20 00 orcc %o0, 0, %i5
400032e4: 12 80 00 11 bne 40003328 <rtems_bdpart_new_record+0x7c> <== NEVER TAKEN
400032e8: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
400032ec: c2 06 80 00 ld [ %i2 ], %g1
400032f0: 80 a0 60 00 cmp %g1, 0
400032f4: 02 80 00 0f be 40003330 <rtems_bdpart_new_record+0x84> <== NEVER TAKEN
400032f8: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
400032fc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40003300: 40 00 4a d1 call 40015e44 <memset>
40003304: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
40003308: c2 06 80 00 ld [ %i2 ], %g1
4000330c: 84 10 20 55 mov 0x55, %g2
40003310: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40003314: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
40003318: c2 06 80 00 ld [ %i2 ], %g1
4000331c: 84 10 3f aa mov -86, %g2
40003320: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40003324: c4 28 61 ff stb %g2, [ %g1 + 0x1ff ]
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
40003328: 81 c7 e0 08 ret
4000332c: 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;
40003330: 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;
}
40003334: 81 c7 e0 08 ret <== NOT EXECUTED
40003338: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40002e38 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
40002e38: 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;
40002e3c: 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;
40002e40: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40002e44: 80 a6 e0 00 cmp %i3, 0
40002e48: 02 80 00 0a be 40002e70 <rtems_bdpart_read+0x38> <== NEVER TAKEN
40002e4c: 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;
40002e50: 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 */
40002e54: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
40002e58: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
40002e5c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
40002e60: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
40002e64: 80 a6 a0 00 cmp %i2, 0
40002e68: 12 80 00 04 bne 40002e78 <rtems_bdpart_read+0x40> <== ALWAYS TAKEN
40002e6c: fa 06 c0 00 ld [ %i3 ], %i5
return RTEMS_INVALID_ADDRESS;
40002e70: 81 c7 e0 08 ret <== NOT EXECUTED
40002e74: 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) {
40002e78: 80 a6 60 00 cmp %i1, 0
40002e7c: 02 bf ff fd be 40002e70 <rtems_bdpart_read+0x38> <== NEVER TAKEN
40002e80: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
40002e84: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40002e88: 92 07 bf f8 add %fp, -8, %o1
40002e8c: 94 07 bf fc add %fp, -4, %o2
40002e90: 7f ff ff bf call 40002d8c <rtems_bdpart_get_disk_data>
40002e94: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002e98: b0 92 20 00 orcc %o0, 0, %i0
40002e9c: 12 80 00 14 bne 40002eec <rtems_bdpart_read+0xb4> <== NEVER TAKEN
40002ea0: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
40002ea4: 92 10 20 00 clr %o1
40002ea8: 7f ff ff 44 call 40002bb8 <rtems_bdpart_read_record>
40002eac: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40002eb0: b0 92 20 00 orcc %o0, 0, %i0
40002eb4: 02 80 00 10 be 40002ef4 <rtems_bdpart_read+0xbc> <== ALWAYS TAKEN
40002eb8: c4 07 bf e8 ld [ %fp + -24 ], %g2
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
40002ebc: d0 07 bf f8 ld [ %fp + -8 ], %o0
40002ec0: 80 a2 20 00 cmp %o0, 0
40002ec4: 26 80 00 05 bl,a 40002ed8 <rtems_bdpart_read+0xa0> <== NEVER TAKEN
40002ec8: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
40002ecc: 40 00 09 09 call 400052f0 <close>
40002ed0: 01 00 00 00 nop
}
if (block != NULL) {
40002ed4: d0 07 bf e8 ld [ %fp + -24 ], %o0
40002ed8: 80 a2 20 00 cmp %o0, 0
40002edc: 02 80 00 04 be 40002eec <rtems_bdpart_read+0xb4> <== NEVER TAKEN
40002ee0: 01 00 00 00 nop
rtems_bdbuf_release( block);
40002ee4: 40 00 34 c3 call 400101f0 <rtems_bdbuf_release>
40002ee8: 01 00 00 00 nop
}
return esc;
}
40002eec: 81 c7 e0 08 ret
40002ef0: 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);
40002ef4: 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;
40002ef8: 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);
40002efc: 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;
40002f00: 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);
40002f04: 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);
40002f08: 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);
40002f0c: 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);
40002f10: 92 07 bf ec add %fp, -20, %o1
40002f14: 94 10 00 1c mov %i4, %o2
40002f18: 7f ff ff 54 call 40002c68 <rtems_bdpart_read_mbr_partition>
40002f1c: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002f20: b0 92 20 00 orcc %o0, 0, %i0
40002f24: 32 bf ff e7 bne,a 40002ec0 <rtems_bdpart_read+0x88> <== NEVER TAKEN
40002f28: 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) {
40002f2c: c2 07 bf ec ld [ %fp + -20 ], %g1
40002f30: c2 08 60 08 ldub [ %g1 + 8 ], %g1
40002f34: 80 a0 60 ee cmp %g1, 0xee
40002f38: 02 bf ff e1 be 40002ebc <rtems_bdpart_read+0x84> <== NEVER TAKEN
40002f3c: 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
40002f40: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
40002f44: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
40002f48: 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;
40002f4c: 84 10 20 00 clr %g2
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
40002f50: 82 01 21 bb add %g4, 0x1bb, %g1
40002f54: 88 01 21 b7 add %g4, 0x1b7, %g4
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
40002f58: c6 08 40 00 ldub [ %g1 ], %g3
40002f5c: 85 28 a0 08 sll %g2, 8, %g2
40002f60: 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) {
40002f64: 80 a0 40 04 cmp %g1, %g4
40002f68: 12 bf ff fc bne 40002f58 <rtems_bdpart_read+0x120>
40002f6c: 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;
40002f70: 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(
40002f74: c4 26 60 04 st %g2, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40002f78: c2 2e 60 08 stb %g1, [ %i1 + 8 ]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
40002f7c: 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;
40002f80: a0 04 20 10 add %l0, 0x10, %l0
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40002f84: 92 07 bf ec add %fp, -20, %o1
40002f88: 90 10 00 10 mov %l0, %o0
40002f8c: 94 10 00 1c mov %i4, %o2
40002f90: 7f ff ff 36 call 40002c68 <rtems_bdpart_read_mbr_partition>
40002f94: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
40002f98: 80 a2 20 00 cmp %o0, 0
40002f9c: 12 80 00 4a bne 400030c4 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
40002fa0: 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) {
40002fa4: 32 bf ff f8 bne,a 40002f84 <rtems_bdpart_read+0x14c>
40002fa8: a0 04 20 10 add %l0, 0x10, %l0
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
40002fac: fa 07 bf f0 ld [ %fp + -16 ], %i5
while (ebr != 0) {
40002fb0: 80 a7 60 00 cmp %i5, 0
40002fb4: 02 80 00 2c be 40003064 <rtems_bdpart_read+0x22c> <== NEVER TAKEN
40002fb8: c8 07 bf ec ld [ %fp + -20 ], %g4
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
40002fbc: d0 07 bf fc ld [ %fp + -4 ], %o0
40002fc0: 92 10 00 1d mov %i5, %o1
40002fc4: 7f ff fe fd call 40002bb8 <rtems_bdpart_read_record>
40002fc8: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40002fcc: 80 a2 20 00 cmp %o0, 0
40002fd0: 12 80 00 3d bne 400030c4 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
40002fd4: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
40002fd8: 92 07 bf ec add %fp, -20, %o1
40002fdc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40002fe0: 94 10 00 1c mov %i4, %o2
40002fe4: 90 02 21 be add %o0, 0x1be, %o0
40002fe8: 7f ff ff 20 call 40002c68 <rtems_bdpart_read_mbr_partition>
40002fec: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
40002ff0: 80 a2 20 00 cmp %o0, 0
40002ff4: 12 80 00 34 bne 400030c4 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
40002ff8: c8 07 bf ec ld [ %fp + -20 ], %g4
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
40002ffc: c2 01 00 00 ld [ %g4 ], %g1
40003000: 84 07 40 01 add %i5, %g1, %g2
if (tmp > p->begin) {
40003004: 80 a0 40 02 cmp %g1, %g2
40003008: 3a bf ff ad bcc,a 40002ebc <rtems_bdpart_read+0x84> <== NEVER TAKEN
4000300c: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
40003010: c2 01 20 04 ld [ %g4 + 4 ], %g1
40003014: ba 07 40 01 add %i5, %g1, %i5
if (tmp > p->end) {
40003018: 80 a0 40 1d cmp %g1, %i5
4000301c: 1a 80 00 28 bcc 400030bc <rtems_bdpart_read+0x284> <== NEVER TAKEN
40003020: 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
40003024: c2 07 bf e8 ld [ %fp + -24 ], %g1
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
40003028: 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
4000302c: 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;
40003030: 84 10 20 00 clr %g2
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
40003034: 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);
40003038: ba 06 61 d6 add %i1, 0x1d6, %i5
value = (value << 8) + data [i];
4000303c: c6 0f 40 01 ldub [ %i5 + %g1 ], %g3
40003040: 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) {
40003044: 82 00 7f ff add %g1, -1, %g1
40003048: 80 a0 7f ff cmp %g1, -1
4000304c: 12 bf ff fc bne 4000303c <rtems_bdpart_read+0x204>
40003050: 84 00 c0 02 add %g3, %g2, %g2
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
40003054: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
40003058: 80 a0 60 05 cmp %g1, 5
4000305c: 02 80 00 11 be 400030a0 <rtems_bdpart_read+0x268>
40003060: 80 a0 a0 00 cmp %g2, 0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40003064: 82 21 00 1a sub %g4, %i2, %g1
40003068: 83 38 60 04 sra %g1, 4, %g1
4000306c: 85 28 60 02 sll %g1, 2, %g2
40003070: 82 00 80 01 add %g2, %g1, %g1
40003074: 85 28 60 04 sll %g1, 4, %g2
40003078: 82 00 40 02 add %g1, %g2, %g1
4000307c: 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;
40003080: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40003084: 82 00 40 02 add %g1, %g2, %g1
40003088: 85 28 60 10 sll %g1, 0x10, %g2
4000308c: 82 00 40 02 add %g1, %g2, %g1
40003090: 82 20 00 01 neg %g1
40003094: 82 00 60 01 inc %g1
40003098: 10 bf ff 89 b 40002ebc <rtems_bdpart_read+0x84>
4000309c: 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) {
400030a0: 02 bf ff f2 be 40003068 <rtems_bdpart_read+0x230> <== NEVER TAKEN
400030a4: 82 21 00 1a sub %g4, %i2, %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
400030a8: fa 07 bf f0 ld [ %fp + -16 ], %i5
400030ac: ba 00 80 1d add %g2, %i5, %i5
if (tmp > ebr) {
400030b0: 80 a7 40 02 cmp %i5, %g2
400030b4: 18 bf ff c3 bgu 40002fc0 <rtems_bdpart_read+0x188> <== ALWAYS TAKEN
400030b8: 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;
400030bc: 10 bf ff 80 b 40002ebc <rtems_bdpart_read+0x84> <== NOT EXECUTED
400030c0: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
400030c4: 10 bf ff 7e b 40002ebc <rtems_bdpart_read+0x84> <== NOT EXECUTED
400030c8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
40002c68 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
40002c68: 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;
40002c6c: ba 10 20 00 clr %i5
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
40002c70: 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
)
{
40002c74: b8 10 00 18 mov %i0, %i4
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
40002c78: 82 10 00 04 mov %g4, %g1
40002c7c: 86 06 20 07 add %i0, 7, %g3
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
40002c80: c4 08 40 00 ldub [ %g1 ], %g2
40002c84: bb 2f 60 08 sll %i5, 8, %i5
40002c88: 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) {
40002c8c: 80 a0 40 03 cmp %g1, %g3
40002c90: 12 bf ff fc bne 40002c80 <rtems_bdpart_read_mbr_partition+0x18>
40002c94: ba 00 80 1d add %g2, %i5, %i5
40002c98: 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;
40002c9c: 84 10 20 00 clr %g2
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
40002ca0: c6 08 40 00 ldub [ %g1 ], %g3
40002ca4: 85 28 a0 08 sll %g2, 8, %g2
40002ca8: 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) {
40002cac: 80 a0 40 04 cmp %g1, %g4
40002cb0: 12 bf ff fc bne 40002ca0 <rtems_bdpart_read_mbr_partition+0x38>
40002cb4: 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) {
40002cb8: e0 0f 20 04 ldub [ %i4 + 4 ], %l0
40002cbc: 80 a4 20 00 cmp %l0, 0
40002cc0: 02 80 00 0a be 40002ce8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40002cc4: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
40002cc8: c2 06 40 00 ld [ %i1 ], %g1
40002ccc: 80 a0 40 1a cmp %g1, %i2
40002cd0: 02 80 00 06 be 40002ce8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40002cd4: 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;
40002cd8: 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) {
40002cdc: 80 a6 80 1d cmp %i2, %i5
40002ce0: 18 80 00 04 bgu 40002cf0 <rtems_bdpart_read_mbr_partition+0x88><== ALWAYS TAKEN
40002ce4: 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;
}
40002ce8: 81 c7 e0 08 ret <== NOT EXECUTED
40002cec: 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) {
40002cf0: 80 a4 20 05 cmp %l0, 5
40002cf4: 12 80 00 08 bne 40002d14 <rtems_bdpart_read_mbr_partition+0xac>
40002cf8: 90 00 60 30 add %g1, 0x30, %o0
if (ep_begin != NULL) {
40002cfc: 80 a6 e0 00 cmp %i3, 0
40002d00: 02 80 00 15 be 40002d54 <rtems_bdpart_read_mbr_partition+0xec><== NEVER TAKEN
40002d04: 01 00 00 00 nop
*ep_begin = begin;
40002d08: 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;
40002d0c: 81 c7 e0 08 ret
40002d10: 91 e8 20 00 restore %g0, 0, %o0
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
40002d14: 94 10 20 30 mov 0x30, %o2
40002d18: 92 10 20 00 clr %o1
40002d1c: 40 00 4c 4a call 40015e44 <memset>
40002d20: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
40002d24: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
40002d28: 90 10 00 10 mov %l0, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
40002d2c: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
40002d30: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
40002d34: 7f ff ff c4 call 40002c44 <rtems_bdpart_to_partition_type>
40002d38: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
40002d3c: c2 06 40 00 ld [ %i1 ], %g1
40002d40: c4 0f 00 00 ldub [ %i4 ], %g2
40002d44: c0 20 60 28 clr [ %g1 + 0x28 ]
40002d48: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
}
return RTEMS_SUCCESSFUL;
40002d4c: 81 c7 e0 08 ret
40002d50: 91 e8 20 00 restore %g0, 0, %o0
}
40002d54: 81 c7 e0 08 ret <== NOT EXECUTED
40002d58: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40002bb8 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
40002bb8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
40002bbc: d0 06 80 00 ld [ %i2 ], %o0
40002bc0: 80 a2 20 00 cmp %o0, 0
40002bc4: 22 80 00 08 be,a 40002be4 <rtems_bdpart_read_record+0x2c>
40002bc8: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release( *block);
40002bcc: 40 00 35 89 call 400101f0 <rtems_bdbuf_release>
40002bd0: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40002bd4: 80 a2 20 00 cmp %o0, 0
40002bd8: 12 80 00 13 bne 40002c24 <rtems_bdpart_read_record+0x6c> <== NEVER TAKEN
40002bdc: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
40002be0: 90 10 00 18 mov %i0, %o0
40002be4: 92 10 00 19 mov %i1, %o1
40002be8: 40 00 34 fd call 4000ffdc <rtems_bdbuf_read>
40002bec: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
40002bf0: 80 a2 20 00 cmp %o0, 0
40002bf4: 12 80 00 0c bne 40002c24 <rtems_bdpart_read_record+0x6c> <== NEVER TAKEN
40002bf8: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
40002bfc: c2 06 80 00 ld [ %i2 ], %g1
40002c00: 80 a0 60 00 cmp %g1, 0
40002c04: 22 80 00 0e be,a 40002c3c <rtems_bdpart_read_record+0x84><== NEVER TAKEN
40002c08: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
40002c0c: 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]
40002c10: c4 08 61 fe ldub [ %g1 + 0x1fe ], %g2
40002c14: 80 a0 a0 55 cmp %g2, 0x55
40002c18: 22 80 00 05 be,a 40002c2c <rtems_bdpart_read_record+0x74><== ALWAYS TAKEN
40002c1c: 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;
40002c20: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
40002c24: 81 c7 e0 08 ret
40002c28: 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]
40002c2c: 80 a0 60 aa cmp %g1, 0xaa
40002c30: 32 bf ff fd bne,a 40002c24 <rtems_bdpart_read_record+0x6c><== NEVER TAKEN
40002c34: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
40002c38: 30 bf ff fb b,a 40002c24 <rtems_bdpart_read_record+0x6c>
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40002c3c: 81 c7 e0 08 ret <== NOT EXECUTED
40002c40: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400030cc <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
400030cc: 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);
400030d0: 90 10 00 18 mov %i0, %o0
400030d4: 40 00 4d 0e call 4001650c <strlen>
400030d8: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
400030dc: 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
)
{
400030e0: 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);
400030e4: a4 10 00 08 mov %o0, %l2
size_t i = 0;
int fd = -1;
400030e8: 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);
400030ec: 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;
400030f0: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400030f4: 92 07 bf f8 add %fp, -8, %o1
400030f8: 94 07 bf fc add %fp, -4, %o2
400030fc: 7f ff ff 24 call 40002d8c <rtems_bdpart_get_disk_data>
40003100: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003104: b0 92 20 00 orcc %o0, 0, %i0
40003108: 12 80 00 32 bne 400031d0 <rtems_bdpart_register+0x104> <== NEVER TAKEN
4000310c: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
40003110: 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;
40003114: e2 00 60 04 ld [ %g1 + 4 ], %l1
40003118: 40 00 08 76 call 400052f0 <close>
4000311c: 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);
40003120: 90 04 a0 04 add %l2, 4, %o0
40003124: 40 00 0a 32 call 400059ec <malloc>
40003128: b8 10 00 11 mov %l1, %i4
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
4000312c: 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) {
40003130: 80 a2 20 00 cmp %o0, 0
40003134: 02 80 00 27 be 400031d0 <rtems_bdpart_register+0x104> <== NEVER TAKEN
40003138: a0 10 00 08 mov %o0, %l0
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
4000313c: 92 10 00 1d mov %i5, %o1
40003140: 40 00 4d 7b call 4001672c <strncpy>
40003144: 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);
40003148: 31 10 00 95 sethi %hi(0x40025400), %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;
4000314c: a4 04 00 12 add %l0, %l2, %l2
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
40003150: ba 10 20 00 clr %i5
40003154: 80 a6 a0 00 cmp %i2, 0
40003158: 12 80 00 06 bne 40003170 <rtems_bdpart_register+0xa4> <== ALWAYS TAKEN
4000315c: b0 16 22 40 or %i0, 0x240, %i0
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40003160: 10 80 00 1a b 400031c8 <rtems_bdpart_register+0xfc> <== NOT EXECUTED
40003164: 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) {
40003168: 02 80 00 1c be 400031d8 <rtems_bdpart_register+0x10c>
4000316c: 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);
40003170: 92 10 20 04 mov 4, %o1
40003174: 94 10 00 18 mov %i0, %o2
40003178: ba 07 60 01 inc %i5
4000317c: 90 10 00 12 mov %l2, %o0
40003180: 40 00 4b f4 call 40016150 <snprintf>
40003184: 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;
40003188: 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) {
4000318c: 80 a2 20 03 cmp %o0, 3
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
40003190: 92 10 00 1c mov %i4, %o1
40003194: 94 10 00 1b mov %i3, %o2
40003198: 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) {
4000319c: 14 80 00 11 bg 400031e0 <rtems_bdpart_register+0x114> <== NEVER TAKEN
400031a0: 90 10 00 1b mov %i3, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
400031a4: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
400031a8: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
400031ac: e0 23 a0 5c st %l0, [ %sp + 0x5c ]
400031b0: 40 00 03 7d call 40003fa4 <rtems_disk_create_log>
400031b4: 9a 23 40 0c sub %o5, %o4, %o5
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
400031b8: 80 a2 20 00 cmp %o0, 0
400031bc: 02 bf ff eb be 40003168 <rtems_bdpart_register+0x9c> <== ALWAYS TAKEN
400031c0: 80 a7 40 1a cmp %i5, %i2
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
400031c4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
400031c8: 40 00 08 6c call 40005378 <free>
400031cc: 90 10 00 10 mov %l0, %o0
return esc;
}
400031d0: 81 c7 e0 08 ret
400031d4: 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;
400031d8: 10 bf ff fc b 400031c8 <rtems_bdpart_register+0xfc>
400031dc: 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;
400031e0: 10 bf ff fa b 400031c8 <rtems_bdpart_register+0xfc> <== NOT EXECUTED
400031e4: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
400031e8 <rtems_bdpart_register_from_disk>:
return esc;
}
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
400031e8: 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;
400031ec: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
400031f0: 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;
400031f4: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
400031f8: 92 07 bc ec add %fp, -788, %o1
400031fc: 94 07 bd 00 add %fp, -768, %o2
40003200: 7f ff ff 0e call 40002e38 <rtems_bdpart_read>
40003204: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003208: 80 a2 20 00 cmp %o0, 0
4000320c: 12 80 00 05 bne 40003220 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
40003210: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
40003214: 90 10 00 18 mov %i0, %o0
40003218: 7f ff ff ad call 400030cc <rtems_bdpart_register>
4000321c: 92 07 bd 00 add %fp, -768, %o1
}
40003220: 81 c7 e0 08 ret
40003224: 91 e8 00 08 restore %g0, %o0, %o0
40023ff4 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40023ff4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
40023ff8: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
40023ffc: 40 00 7d 4c call 4004352c <strrchr> <== NOT EXECUTED
40024000: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024004: 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);
40024008: 40 00 79 26 call 400424a0 <strlen> <== NOT EXECUTED
4002400c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024010: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
40024014: 40 00 79 23 call 400424a0 <strlen> <== NOT EXECUTED
40024018: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
4002401c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40024020: 02 80 00 42 be 40024128 <rtems_bdpart_unmount+0x134> <== NOT EXECUTED
40024024: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
disk_file_name += 1;
40024028: a2 07 20 01 add %i4, 1, %l1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
4002402c: 40 00 79 1d call 400424a0 <strlen> <== NOT EXECUTED
40024030: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40024034: 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);
40024038: b2 04 00 1d add %l0, %i5, %i1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
4002403c: 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);
40024040: 7f ff 7b ae call 40002ef8 <malloc> <== NOT EXECUTED
40024044: 90 06 60 05 add %i1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
40024048: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002404c: 02 80 00 2b be 400240f8 <rtems_bdpart_unmount+0x104> <== NOT EXECUTED
40024050: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
40024054: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40024058: 40 00 79 ce call 40042790 <strncpy> <== NOT EXECUTED
4002405c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
40024060: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40024064: 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] = '/';
40024068: c2 2f 00 1d stb %g1, [ %i4 + %i5 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
4002406c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
40024070: 90 07 00 08 add %i4, %o0, %o0 <== NOT EXECUTED
40024074: 40 00 79 c7 call 40042790 <strncpy> <== NOT EXECUTED
40024078: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
4002407c: 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);
40024080: 37 10 01 81 sethi %hi(0x40060400), %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) {
40024084: 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;
40024088: b2 07 00 19 add %i4, %i1, %i1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
4002408c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40024090: 12 80 00 06 bne 400240a8 <rtems_bdpart_unmount+0xb4> <== NOT EXECUTED
40024094: b6 16 e3 08 or %i3, 0x308, %i3 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
40024098: 10 80 00 1c b 40024108 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
4002409c: 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) {
400240a0: 02 80 00 1a be 40024108 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
400240a4: b0 10 20 00 clr %i0 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400240a8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400240ac: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
400240b0: ba 07 60 01 inc %i5 <== NOT EXECUTED
400240b4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400240b8: 40 00 75 82 call 400416c0 <snprintf> <== NOT EXECUTED
400240bc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
400240c0: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
400240c4: 14 80 00 15 bg 40024118 <rtems_bdpart_unmount+0x124> <== NOT EXECUTED
400240c8: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
400240cc: 40 00 11 45 call 400285e0 <unmount> <== NOT EXECUTED
400240d0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rv == 0) {
400240d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400240d8: 12 bf ff f2 bne 400240a0 <rtems_bdpart_unmount+0xac> <== NOT EXECUTED
400240dc: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
400240e0: 40 00 0f 8b call 40027f0c <rmdir> <== NOT EXECUTED
400240e4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rv != 0) {
400240e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400240ec: 02 bf ff ed be 400240a0 <rtems_bdpart_unmount+0xac> <== NOT EXECUTED
400240f0: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
400240f4: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
400240f8: 7f ff 7a a6 call 40002b90 <free> <== NOT EXECUTED
400240fc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
40024100: 81 c7 e0 08 ret <== NOT EXECUTED
40024104: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
40024108: 7f ff 7a a2 call 40002b90 <free> <== NOT EXECUTED
4002410c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
40024110: 81 c7 e0 08 ret <== NOT EXECUTED
40024114: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
40024118: 7f ff 7a 9e call 40002b90 <free> <== NOT EXECUTED
4002411c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
40024120: 81 c7 e0 08 ret <== NOT EXECUTED
40024124: 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;
40024128: 10 bf ff c4 b 40024038 <rtems_bdpart_unmount+0x44> <== NOT EXECUTED
4002412c: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
40003228 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
40003228: 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;
4000322c: 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);
40003230: 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;
40003234: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
40003238: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
4000323c: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40003240: 92 07 bf f8 add %fp, -8, %o1
40003244: 94 07 bf fc add %fp, -4, %o2
40003248: 7f ff fe d1 call 40002d8c <rtems_bdpart_get_disk_data>
4000324c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003250: b0 92 20 00 orcc %o0, 0, %i0
40003254: 12 80 00 14 bne 400032a4 <rtems_bdpart_unregister+0x7c> <== NEVER TAKEN
40003258: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
4000325c: d0 07 bf f8 ld [ %fp + -8 ], %o0
40003260: 40 00 08 24 call 400052f0 <close>
40003264: 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) {
40003268: 80 a6 a0 00 cmp %i2, 0
4000326c: 12 80 00 05 bne 40003280 <rtems_bdpart_unregister+0x58> <== ALWAYS TAKEN
40003270: b4 06 80 1d add %i2, %i5, %i2
40003274: 30 80 00 0c b,a 400032a4 <rtems_bdpart_unregister+0x7c> <== NOT EXECUTED
40003278: 02 80 00 0b be 400032a4 <rtems_bdpart_unregister+0x7c>
4000327c: 01 00 00 00 nop
/* New minor number */
++minor;
40003280: 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);
40003284: 90 10 00 1c mov %i4, %o0
40003288: 40 00 02 cc call 40003db8 <rtems_disk_delete>
4000328c: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
40003290: 80 a2 20 00 cmp %o0, 0
40003294: 02 bf ff f9 be 40003278 <rtems_bdpart_unregister+0x50> <== ALWAYS TAKEN
40003298: 80 a7 40 1a cmp %i5, %i2
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
4000329c: 81 c7 e0 08 ret <== NOT EXECUTED
400032a0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400032a4: 81 c7 e0 08 ret
400032a8: 81 e8 00 00 restore
4000333c <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
4000333c: 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;
40003340: 80 a6 60 00 cmp %i1, 0
40003344: 02 80 00 06 be 4000335c <rtems_bdpart_write+0x20> <== NEVER TAKEN
40003348: 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
4000334c: c2 06 40 00 ld [ %i1 ], %g1
40003350: 80 a0 60 00 cmp %g1, 0
40003354: 22 80 00 11 be,a 40003398 <rtems_bdpart_write+0x5c> <== ALWAYS TAKEN
40003358: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
4000335c: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
40003360: 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
40003364: 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 =
40003368: 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;
4000336c: 82 10 3f ff mov -1, %g1
rtems_disk_device *dd = NULL;
40003370: 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;
40003374: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
40003378: 80 a6 e0 00 cmp %i3, 0
4000337c: 02 80 00 4e be 400034b4 <rtems_bdpart_write+0x178> <== NEVER TAKEN
40003380: b0 10 20 00 clr %i0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
40003384: 80 a6 a0 00 cmp %i2, 0
40003388: 12 80 00 0b bne 400033b4 <rtems_bdpart_write+0x78> <== ALWAYS TAKEN
4000338c: 80 a6 60 00 cmp %i1, 0
return RTEMS_INVALID_ADDRESS;
40003390: 81 c7 e0 08 ret <== NOT EXECUTED
40003394: 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;
40003398: 80 a0 60 00 cmp %g1, 0
4000339c: 02 bf ff f1 be 40003360 <rtems_bdpart_write+0x24> <== NEVER TAKEN
400033a0: c0 27 bf f0 clr [ %fp + -16 ]
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
400033a4: 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
400033a8: 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 =
400033ac: 10 bf ff f0 b 4000336c <rtems_bdpart_write+0x30>
400033b0: b8 10 20 3f mov 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
400033b4: 02 bf ff f7 be 40003390 <rtems_bdpart_write+0x54> <== NEVER TAKEN
400033b8: 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);
400033bc: 94 07 bf fc add %fp, -4, %o2
400033c0: 7f ff fe 73 call 40002d8c <rtems_bdpart_get_disk_data>
400033c4: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
400033c8: b0 92 20 00 orcc %o0, 0, %i0
400033cc: 12 80 00 3a bne 400034b4 <rtems_bdpart_write+0x178> <== NEVER TAKEN
400033d0: ba 8f 60 ff andcc %i5, 0xff, %i5
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
400033d4: 32 80 00 25 bne,a 40003468 <rtems_bdpart_write+0x12c> <== ALWAYS TAKEN
400033d8: f0 07 bf f4 ld [ %fp + -12 ], %i0
400033dc: 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) {
400033e0: de 06 80 00 ld [ %i2 ], %o7
400033e4: 80 a3 c0 08 cmp %o7, %o0
400033e8: 3a 80 00 27 bcc,a 40003484 <rtems_bdpart_write+0x148> <== NEVER TAKEN
400033ec: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
400033f0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400033f4: 80 a2 00 01 cmp %o0, %g1
400033f8: 0a 80 00 22 bcs 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
400033fc: 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) {
40003400: 1a 80 00 20 bcc 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40003404: a2 10 00 1a mov %i2, %l1
40003408: 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) {
4000340c: 84 10 20 00 clr %g2
40003410: 84 00 a0 01 inc %g2
40003414: 80 a0 80 1b cmp %g2, %i3
40003418: 22 80 00 29 be,a 400034bc <rtems_bdpart_write+0x180>
4000341c: 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) {
40003420: c6 00 60 30 ld [ %g1 + 0x30 ], %g3
40003424: 80 a0 c0 08 cmp %g3, %o0
40003428: 3a 80 00 17 bcc,a 40003484 <rtems_bdpart_write+0x148> <== NEVER TAKEN
4000342c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
40003430: c8 00 60 34 ld [ %g1 + 0x34 ], %g4
40003434: 80 a1 00 08 cmp %g4, %o0
40003438: 18 80 00 12 bgu 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
4000343c: 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) {
40003440: 1a 80 00 10 bcc 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40003444: 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) {
40003448: 22 bf ff f2 be,a 40003410 <rtems_bdpart_write+0xd4> <== NEVER TAKEN
4000344c: 82 00 60 30 add %g1, 0x30, %g1 <== NOT EXECUTED
40003450: c8 00 60 04 ld [ %g1 + 4 ], %g4
40003454: 80 a0 c0 04 cmp %g3, %g4
40003458: 0a 80 00 0a bcs 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
4000345c: 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) {
40003460: 10 bf ff ed b 40003414 <rtems_bdpart_write+0xd8>
40003464: 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);
40003468: 92 10 00 1c mov %i4, %o1
4000346c: 40 00 7a a5 call 40021f00 <.urem>
40003470: 90 10 00 18 mov %i0, %o0
40003474: 90 26 00 08 sub %i0, %o0, %o0
40003478: 10 bf ff da b 400033e0 <rtems_bdpart_write+0xa4>
4000347c: 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;
40003480: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
40003484: d0 07 bf f8 ld [ %fp + -8 ], %o0
40003488: 80 a2 20 00 cmp %o0, 0
4000348c: 26 80 00 05 bl,a 400034a0 <rtems_bdpart_write+0x164> <== NEVER TAKEN
40003490: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
40003494: 40 00 07 97 call 400052f0 <close>
40003498: 01 00 00 00 nop
}
if (block != NULL) {
4000349c: d0 07 bf f0 ld [ %fp + -16 ], %o0
400034a0: 80 a2 20 00 cmp %o0, 0
400034a4: 02 80 00 04 be 400034b4 <rtems_bdpart_write+0x178> <== NEVER TAKEN
400034a8: 01 00 00 00 nop
rtems_bdbuf_sync( block);
400034ac: 40 00 33 a9 call 40010350 <rtems_bdbuf_sync>
400034b0: 01 00 00 00 nop
400034b4: 81 c7 e0 08 ret
400034b8: 81 e8 00 00 restore
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
400034bc: 80 a0 60 00 cmp %g1, 0
400034c0: 12 bf ff f1 bne 40003484 <rtems_bdpart_write+0x148> <== NEVER TAKEN
400034c4: 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;
400034c8: 80 a6 e0 04 cmp %i3, 4
400034cc: 08 80 00 03 bleu 400034d8 <rtems_bdpart_write+0x19c> <== NEVER TAKEN
400034d0: a0 10 00 1b mov %i3, %l0
400034d4: 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) {
400034d8: 80 a7 60 00 cmp %i5, 0
400034dc: 02 80 00 06 be 400034f4 <rtems_bdpart_write+0x1b8> <== NEVER TAKEN
400034e0: 80 a4 00 1b cmp %l0, %i3
400034e4: 80 a3 e0 3f cmp %o7, 0x3f
400034e8: 12 bf ff e7 bne 40003484 <rtems_bdpart_write+0x148> <== NEVER TAKEN
400034ec: 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) {
400034f0: 80 a4 00 1b cmp %l0, %i3
400034f4: 1a 80 00 1c bcc 40003564 <rtems_bdpart_write+0x228> <== NEVER TAKEN
400034f8: 84 04 3f ff add %l0, -1, %g2
if ((pt [i].begin - pt [i - 1].end) < record_space) {
400034fc: 89 2c 20 06 sll %l0, 6, %g4
40003500: 87 28 a0 04 sll %g2, 4, %g3
40003504: 83 2c 20 04 sll %l0, 4, %g1
40003508: 85 28 a0 06 sll %g2, 6, %g2
4000350c: 82 21 00 01 sub %g4, %g1, %g1
40003510: 84 20 80 03 sub %g2, %g3, %g2
40003514: c8 06 80 01 ld [ %i2 + %g1 ], %g4
40003518: 84 06 80 02 add %i2, %g2, %g2
4000351c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40003520: 84 06 80 01 add %i2, %g1, %g2
40003524: 82 21 00 03 sub %g4, %g3, %g1
40003528: 80 a7 00 01 cmp %i4, %g1
4000352c: 18 bf ff d5 bgu 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40003530: 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) {
40003534: 10 80 00 09 b 40003558 <rtems_bdpart_write+0x21c>
40003538: 82 00 60 01 inc %g1
if ((pt [i].begin - pt [i - 1].end) < record_space) {
4000353c: c8 00 e0 30 ld [ %g3 + 0x30 ], %g4
40003540: c6 00 e0 04 ld [ %g3 + 4 ], %g3
40003544: 86 21 00 03 sub %g4, %g3, %g3
40003548: 80 a7 00 03 cmp %i4, %g3
4000354c: 18 bf ff cd bgu 40003480 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40003550: 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) {
40003554: 82 00 60 01 inc %g1
40003558: 80 a6 c0 01 cmp %i3, %g1
4000355c: 18 bf ff f8 bgu 4000353c <rtems_bdpart_write+0x200>
40003560: 86 10 00 02 mov %g2, %g3
40003564: ba 10 00 1a mov %i2, %i5
40003568: b0 10 20 00 clr %i0
4000356c: 10 80 00 0c b 4000359c <rtems_bdpart_write+0x260>
40003570: a4 07 bf ef add %fp, -17, %l2
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
40003574: 80 a0 60 00 cmp %g1, 0
40003578: 12 80 00 10 bne 400035b8 <rtems_bdpart_write+0x27c> <== NEVER TAKEN
4000357c: b0 06 20 01 inc %i0
40003580: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40003584: 80 a0 60 ff cmp %g1, 0xff
40003588: 18 80 00 0c bgu 400035b8 <rtems_bdpart_write+0x27c> <== NEVER TAKEN
4000358c: 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) {
40003590: 80 a6 00 1b cmp %i0, %i3
40003594: 02 80 00 0b be 400035c0 <rtems_bdpart_write+0x284>
40003598: 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)) {
4000359c: 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;
400035a0: 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)) {
400035a4: 7f ff fd ee call 40002d5c <rtems_bdpart_to_mbr_partition_type>
400035a8: 92 10 00 12 mov %l2, %o1
400035ac: 80 8a 20 ff btst 0xff, %o0
400035b0: 32 bf ff f1 bne,a 40003574 <rtems_bdpart_write+0x238> <== ALWAYS TAKEN
400035b4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400035b8: 10 bf ff b3 b 40003484 <rtems_bdpart_write+0x148> <== NOT EXECUTED
400035bc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
400035c0: 92 10 20 00 clr %o1
400035c4: 7f ff ff 3a call 400032ac <rtems_bdpart_new_record>
400035c8: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
400035cc: b0 92 20 00 orcc %o0, 0, %i0
400035d0: 12 bf ff ae bne 40003488 <rtems_bdpart_write+0x14c> <== NEVER TAKEN
400035d4: 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
400035d8: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
400035dc: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
400035e0: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
400035e4: 82 00 e1 b8 add %g3, 0x1b8, %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400035e8: 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;
400035ec: c4 28 40 00 stb %g2, [ %g1 ]
400035f0: 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) {
400035f4: 80 a0 40 03 cmp %g1, %g3
400035f8: 12 bf ff fd bne 400035ec <rtems_bdpart_write+0x2b0>
400035fc: 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;
40003600: c2 07 bf f0 ld [ %fp + -16 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40003604: 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;
40003608: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
4000360c: 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;
40003610: 9a 01 21 be add %g4, 0x1be, %o5
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40003614: 98 23 00 0f sub %o4, %o7, %o4
40003618: 88 01 21 ca add %g4, 0x1ca, %g4
4000361c: b0 06 80 0c add %i2, %o4, %i0
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
data,
p->begin,
p->end - p->begin,
40003620: 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(
40003624: c6 04 60 04 ld [ %l1 + 4 ], %g3
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
40003628: 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(
4000362c: fa 0c 60 2f ldub [ %l1 + 0x2f ], %i5
40003630: 86 20 c0 02 sub %g3, %g2, %g3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40003634: 82 01 3f fc add %g4, -4, %g1
data [i] = (uint8_t) value;
40003638: c4 28 40 00 stb %g2, [ %g1 ]
4000363c: 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) {
40003640: 80 a1 00 01 cmp %g4, %g1
40003644: 12 bf ff fd bne 40003638 <rtems_bdpart_write+0x2fc>
40003648: 85 30 a0 08 srl %g2, 8, %g2
4000364c: 84 01 20 04 add %g4, 4, %g2
40003650: 82 10 00 04 mov %g4, %g1
data [i] = (uint8_t) value;
40003654: c6 28 40 00 stb %g3, [ %g1 ]
40003658: 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) {
4000365c: 80 a0 40 02 cmp %g1, %g2
40003660: 12 bf ff fd bne 40003654 <rtems_bdpart_write+0x318>
40003664: 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;
40003668: f2 29 3f f8 stb %i1, [ %g4 + -8 ]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
4000366c: fa 29 3f f4 stb %i5, [ %g4 + -12 ]
40003670: 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) {
40003674: 80 a4 40 18 cmp %l1, %i0
40003678: 12 bf ff ea bne 40003620 <rtems_bdpart_write+0x2e4>
4000367c: 88 01 20 10 add %g4, 0x10, %g4
40003680: 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) {
40003684: 80 a4 00 1b cmp %l0, %i3
40003688: 02 bf ff 7f be 40003484 <rtems_bdpart_write+0x148> <== NEVER TAKEN
4000368c: 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;
40003690: fa 06 80 0c ld [ %i2 + %o4 ], %i5
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
40003694: 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;
40003698: 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);
4000369c: 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(
400036a0: 86 20 c0 1d sub %g3, %i5, %g3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400036a4: b2 00 a0 0c add %g2, 0xc, %i1
400036a8: 88 10 00 1d mov %i5, %g4
data [i] = (uint8_t) value;
400036ac: c8 28 40 00 stb %g4, [ %g1 ]
400036b0: 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) {
400036b4: 80 a0 40 19 cmp %g1, %i1
400036b8: 12 bf ff fd bne 400036ac <rtems_bdpart_write+0x370>
400036bc: 89 31 20 08 srl %g4, 8, %g4
400036c0: 88 00 a0 10 add %g2, 0x10, %g4
data [i] = (uint8_t) value;
400036c4: c6 28 40 00 stb %g3, [ %g1 ]
400036c8: 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) {
400036cc: 80 a0 40 04 cmp %g1, %g4
400036d0: 12 bf ff fd bne 400036c4 <rtems_bdpart_write+0x388>
400036d4: 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;
400036d8: 82 10 20 05 mov 5, %g1
400036dc: c2 28 a0 04 stb %g1, [ %g2 + 4 ]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
400036e0: 80 a4 00 1b cmp %l0, %i3
400036e4: 1a 80 00 44 bcc 400037f4 <rtems_bdpart_write+0x4b8> <== NEVER TAKEN
400036e8: c0 2b 40 0f clrb [ %o5 + %o7 ]
400036ec: 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;
400036f0: b2 10 20 05 mov 5, %i1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400036f4: 83 2c a0 04 sll %l2, 4, %g1
400036f8: 85 2c a0 06 sll %l2, 6, %g2
400036fc: 82 20 80 01 sub %g2, %g1, %g1
40003700: b4 06 80 01 add %i2, %g1, %i2
0
);
}
/* New EBR */
ebr = p->begin - record_space;
40003704: d2 04 40 00 ld [ %l1 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
40003708: d0 07 bf fc ld [ %fp + -4 ], %o0
4000370c: 92 22 40 1c sub %o1, %i4, %o1
40003710: 7f ff fe e7 call 400032ac <rtems_bdpart_new_record>
40003714: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
40003718: 80 a2 20 00 cmp %o0, 0
4000371c: 12 80 00 34 bne 400037ec <rtems_bdpart_write+0x4b0> <== NEVER TAKEN
40003720: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
40003724: c4 04 60 04 ld [ %l1 + 4 ], %g2
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
40003728: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
4000372c: c2 04 40 00 ld [ %l1 ], %g1
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
40003730: de 0c 60 08 ldub [ %l1 + 8 ], %o7
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
40003734: f0 0c 60 2f ldub [ %l1 + 0x2f ], %i0
40003738: 84 20 80 01 sub %g2, %g1, %g2
data [i] = (uint8_t) value;
4000373c: f8 28 e1 c6 stb %i4, [ %g3 + 0x1c6 ]
40003740: c0 28 e1 c7 clrb [ %g3 + 0x1c7 ]
40003744: c0 28 e1 c8 clrb [ %g3 + 0x1c8 ]
40003748: 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);
4000374c: 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) {
40003750: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
40003754: 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) {
40003758: 82 00 60 01 inc %g1
4000375c: 80 a0 60 04 cmp %g1, 4
40003760: 12 bf ff fd bne 40003754 <rtems_bdpart_write+0x418>
40003764: 85 30 a0 08 srl %g2, 8, %g2
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40003768: de 28 e1 c2 stb %o7, [ %g3 + 0x1c2 ]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
4000376c: 80 a4 80 1b cmp %l2, %i3
40003770: 02 80 00 21 be 400037f4 <rtems_bdpart_write+0x4b8>
40003774: f0 28 e1 be stb %i0, [ %g3 + 0x1be ]
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
40003778: 80 a4 00 12 cmp %l0, %l2
4000377c: 1a 80 00 19 bcc 400037e0 <rtems_bdpart_write+0x4a4> <== NEVER TAKEN
40003780: 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,
40003784: 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;
40003788: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
4000378c: 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(
40003790: 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;
40003794: 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);
40003798: 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(
4000379c: 86 20 40 1d sub %g1, %i5, %g3
400037a0: 84 20 80 01 sub %g2, %g1, %g2
400037a4: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
400037a8: 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) {
400037ac: 82 00 60 01 inc %g1
400037b0: 80 a0 60 04 cmp %g1, 4
400037b4: 12 bf ff fd bne 400037a8 <rtems_bdpart_write+0x46c>
400037b8: 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);
400037bc: 86 06 21 da add %i0, 0x1da, %g3
400037c0: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
400037c4: 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) {
400037c8: 82 00 60 01 inc %g1
400037cc: 80 a0 60 04 cmp %g1, 4
400037d0: 12 bf ff fd bne 400037c4 <rtems_bdpart_write+0x488>
400037d4: 85 30 a0 08 srl %g2, 8, %g2
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
400037d8: f2 2e 21 d2 stb %i1, [ %i0 + 0x1d2 ]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
400037dc: c0 2e 21 ce clrb [ %i0 + 0x1ce ]
400037e0: a4 04 a0 01 inc %l2
400037e4: 10 bf ff c8 b 40003704 <rtems_bdpart_write+0x3c8>
400037e8: 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) {
400037ec: 10 bf ff 26 b 40003484 <rtems_bdpart_write+0x148> <== NOT EXECUTED
400037f0: 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;
400037f4: 10 bf ff 24 b 40003484 <rtems_bdpart_write+0x148>
400037f8: b0 10 20 00 clr %i0
4000330c <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
4000330c: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
40003310: 92 10 20 02 mov 2, %o1
40003314: 90 10 00 19 mov %i1, %o0
40003318: 40 00 09 a0 call 40005998 <open>
4000331c: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
40003320: b0 10 20 04 mov 4, %i0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
if (fd >= 0) {
40003324: 80 a2 20 00 cmp %o0, 0
40003328: 06 80 00 0a bl 40003350 <rtems_blkdev_create_partition+0x44>
4000332c: ba 10 00 08 mov %o0, %i5
int rv;
struct stat st;
rv = fstat(fd, &st);
40003330: 40 00 06 12 call 40004b78 <fstat>
40003334: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
40003338: 80 a2 20 00 cmp %o0, 0
4000333c: 02 80 00 07 be 40003358 <rtems_blkdev_create_partition+0x4c><== ALWAYS TAKEN
40003340: f2 07 bf c4 ld [ %fp + -60 ], %i1
40003344: b0 10 20 15 mov 0x15, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
40003348: 40 00 05 c0 call 40004a48 <close>
4000334c: 90 10 00 1d mov %i5, %o0
40003350: 81 c7 e0 08 ret
40003354: 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)) {
40003358: 03 00 00 3c sethi %hi(0xf000), %g1
4000335c: b2 0e 40 01 and %i1, %g1, %i1
40003360: 03 00 00 18 sethi %hi(0x6000), %g1
40003364: 80 a6 40 01 cmp %i1, %g1
40003368: 12 bf ff f8 bne 40003348 <rtems_blkdev_create_partition+0x3c>
4000336c: 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);
40003370: 90 10 00 1d mov %i5, %o0
40003374: 94 07 bf b4 add %fp, -76, %o2
40003378: 13 10 01 10 sethi %hi(0x40044000), %o1
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_NOT_IMPLEMENTED;
4000337c: b0 10 20 18 mov 0x18, %i0
40003380: 40 00 06 54 call 40004cd0 <ioctl>
40003384: 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) {
40003388: 80 a2 20 00 cmp %o0, 0
4000338c: 12 bf ff ef bne 40003348 <rtems_blkdev_create_partition+0x3c>
40003390: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
40003394: 40 00 07 6c call 40005144 <malloc>
40003398: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
4000339c: a0 92 20 00 orcc %o0, 0, %l0
400033a0: 02 80 00 17 be 400033fc <rtems_blkdev_create_partition+0xf0>
400033a4: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
400033a8: 94 10 00 1a mov %i2, %o2
400033ac: 40 00 00 96 call 40003604 <rtems_disk_init_log>
400033b0: 96 10 00 1b mov %i3, %o3
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
400033b4: b0 92 20 00 orcc %o0, 0, %i0
400033b8: 12 80 00 0e bne 400033f0 <rtems_blkdev_create_partition+0xe4>
400033bc: 90 10 00 1c mov %i4, %o0
ctx->fd = fd;
400033c0: fa 24 20 78 st %i5, [ %l0 + 0x78 ]
rv = IMFS_make_generic_node(
400033c4: 92 16 61 ff or %i1, 0x1ff, %o1
400033c8: 96 10 00 10 mov %l0, %o3
400033cc: 15 10 00 68 sethi %hi(0x4001a000), %o2
400033d0: 40 00 03 cb call 400042fc <IMFS_make_generic_node>
400033d4: 94 12 a0 50 or %o2, 0x50, %o2 ! 4001a050 <rtems_blkdev_imfs_control>
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
400033d8: 80 a2 20 00 cmp %o0, 0
400033dc: 02 bf ff dd be 40003350 <rtems_blkdev_create_partition+0x44>
400033e0: 90 10 00 10 mov %l0, %o0
free(ctx);
400033e4: 40 00 05 bb call 40004ad0 <free>
400033e8: b0 10 20 0d mov 0xd, %i0
400033ec: 30 bf ff d7 b,a 40003348 <rtems_blkdev_create_partition+0x3c>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
400033f0: 40 00 05 b8 call 40004ad0 <free>
400033f4: 90 10 00 10 mov %l0, %o0
400033f8: 30 bf ff d4 b,a 40003348 <rtems_blkdev_create_partition+0x3c>
}
} else {
sc = RTEMS_NO_MEMORY;
400033fc: 10 bf ff d3 b 40003348 <rtems_blkdev_create_partition+0x3c>
40003400: b0 10 20 1a mov 0x1a, %i0
4000f468 <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)
{
4000f468: 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;
4000f46c: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
4000f470: 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;
4000f474: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
4000f478: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000f47c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000f480: 80 a2 40 01 cmp %o1, %g1
4000f484: 12 80 00 05 bne 4000f498 <rtems_blkdev_generic_ioctl+0x30><== ALWAYS TAKEN
4000f488: 82 10 3f ff mov -1, %g1
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
4000f48c: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
4000f490: 81 c7 e0 08 ret <== NOT EXECUTED
4000f494: 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,
4000f498: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000f49c: d4 06 a0 08 ld [ %i2 + 8 ], %o2
4000f4a0: 9f c0 40 00 call %g1
4000f4a4: b0 10 20 00 clr %i0
4000f4a8: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
*/
args->ioctl_return = -1;
}
return RTEMS_SUCCESSFUL;
}
4000f4ac: 81 c7 e0 08 ret
4000f4b0: 81 e8 00 00 restore
4000f224 <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)
{
4000f224: 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;
4000f228: 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);
4000f22c: 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;
4000f230: 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);
4000f234: 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;
4000f238: 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);
4000f23c: 90 10 00 1c mov %i4, %o0
4000f240: 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;
4000f244: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000f248: 40 00 22 06 call 40017a60 <__divdi3>
4000f24c: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000f250: 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);
4000f254: b2 10 00 09 mov %o1, %i1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000f258: 94 10 20 00 clr %o2
4000f25c: 92 10 00 1d mov %i5, %o1
4000f260: 40 00 22 eb call 40017e0c <__moddi3>
4000f264: 96 10 00 11 mov %l1, %o3
args->bytes_moved = 0;
4000f268: 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);
4000f26c: a0 10 00 09 mov %o1, %l0
args->bytes_moved = 0;
while (count > 0)
4000f270: 80 a6 e0 00 cmp %i3, 0
4000f274: 12 80 00 1a bne 4000f2dc <rtems_blkdev_generic_read+0xb8> <== ALWAYS TAKEN
4000f278: 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;
4000f27c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f280: 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;
4000f284: ba 24 40 10 sub %l1, %l0, %i5
4000f288: 80 a7 40 1b cmp %i5, %i3
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4000f28c: 08 80 00 03 bleu 4000f298 <rtems_blkdev_generic_read+0x74><== ALWAYS TAKEN
4000f290: c2 07 bf fc ld [ %fp + -4 ], %g1
4000f294: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
4000f298: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
4000f29c: 94 10 00 1d mov %i5, %o2
4000f2a0: 40 00 15 14 call 400146f0 <memcpy>
4000f2a4: 92 02 40 10 add %o1, %l0, %o1
rc = rtems_bdbuf_release(diskbuf);
4000f2a8: d0 07 bf fc ld [ %fp + -4 ], %o0
4000f2ac: 7f ff fd e9 call 4000ea50 <rtems_bdbuf_release>
4000f2b0: b8 07 00 1d add %i4, %i5, %i4
args->bytes_moved += copy;
4000f2b4: 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);
4000f2b8: b0 10 00 08 mov %o0, %i0
args->bytes_moved += copy;
4000f2bc: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
4000f2c0: 80 a2 20 00 cmp %o0, 0
4000f2c4: 12 80 00 0e bne 4000f2fc <rtems_blkdev_generic_read+0xd8> <== NEVER TAKEN
4000f2c8: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
4000f2cc: 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)
4000f2d0: b6 a6 c0 1d subcc %i3, %i5, %i3
4000f2d4: 02 80 00 0c be 4000f304 <rtems_blkdev_generic_read+0xe0> <== ALWAYS TAKEN
4000f2d8: a0 10 20 00 clr %l0
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
4000f2dc: 92 10 00 19 mov %i1, %o1
4000f2e0: 94 07 bf fc add %fp, -4, %o2
4000f2e4: 7f ff fd 56 call 4000e83c <rtems_bdbuf_read>
4000f2e8: 90 10 00 12 mov %l2, %o0
4000f2ec: b0 10 00 08 mov %o0, %i0
if (rc != RTEMS_SUCCESSFUL)
4000f2f0: 80 a6 20 00 cmp %i0, 0
4000f2f4: 02 bf ff e4 be 4000f284 <rtems_blkdev_generic_read+0x60> <== ALWAYS TAKEN
4000f2f8: 90 10 00 1c mov %i4, %o0
blkofs = 0;
block++;
}
return rc;
}
4000f2fc: 81 c7 e0 08 ret <== NOT EXECUTED
4000f300: 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;
4000f304: b0 10 20 00 clr %i0
4000f308: 81 c7 e0 08 ret
4000f30c: 81 e8 00 00 restore
4000f310 <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)
{
4000f310: 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;
4000f314: 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);
4000f318: 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;
4000f31c: 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);
4000f320: 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;
4000f324: 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);
4000f328: 90 10 00 1c mov %i4, %o0
4000f32c: 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;
4000f330: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000f334: 40 00 21 cb call 40017a60 <__divdi3>
4000f338: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000f33c: 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);
4000f340: b0 10 00 09 mov %o1, %i0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4000f344: 94 10 20 00 clr %o2
4000f348: 92 10 00 1d mov %i5, %o1
4000f34c: 40 00 22 b0 call 40017e0c <__moddi3>
4000f350: 96 10 00 10 mov %l0, %o3
args->bytes_moved = 0;
4000f354: 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);
4000f358: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
while (count > 0)
4000f35c: 80 a6 e0 00 cmp %i3, 0
4000f360: 12 80 00 21 bne 4000f3e4 <rtems_blkdev_generic_write+0xd4><== ALWAYS TAKEN
4000f364: 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;
4000f368: 10 80 00 2c b 4000f418 <rtems_blkdev_generic_write+0x108> <== NOT EXECUTED
4000f36c: 90 10 20 00 clr %o0 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
4000f370: 12 80 00 21 bne 4000f3f4 <rtems_blkdev_generic_write+0xe4><== NEVER TAKEN
4000f374: 92 10 00 18 mov %i0, %o1
rc = rtems_bdbuf_get(dd, block, &diskbuf);
4000f378: 90 10 00 11 mov %l1, %o0
4000f37c: 7f ff fc f0 call 4000e73c <rtems_bdbuf_get>
4000f380: 94 07 bf fc add %fp, -4, %o2
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
4000f384: 80 a2 20 00 cmp %o0, 0
4000f388: 12 80 00 21 bne 4000f40c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
4000f38c: 92 10 00 19 mov %i1, %o1
break;
copy = block_size - blkofs;
4000f390: ba 24 00 1c sub %l0, %i4, %i5
4000f394: 80 a7 40 1b cmp %i5, %i3
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4000f398: 08 80 00 03 bleu 4000f3a4 <rtems_blkdev_generic_write+0x94><== ALWAYS TAKEN
4000f39c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000f3a0: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
4000f3a4: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4000f3a8: 94 10 00 1d mov %i5, %o2
4000f3ac: 40 00 14 d1 call 400146f0 <memcpy>
4000f3b0: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
4000f3b4: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
4000f3b8: 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;
4000f3bc: 82 00 40 1d add %g1, %i5, %g1
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
4000f3c0: 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);
4000f3c4: 7f ff fd db call 4000eb30 <rtems_bdbuf_release_modified>
4000f3c8: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
4000f3cc: 80 a2 20 00 cmp %o0, 0
4000f3d0: 12 80 00 0f bne 4000f40c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
4000f3d4: b6 a6 c0 1d subcc %i3, %i5, %i3
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
4000f3d8: 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)
4000f3dc: 02 80 00 0e be 4000f414 <rtems_blkdev_generic_write+0x104><== ALWAYS TAKEN
4000f3e0: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
4000f3e4: 80 a6 c0 10 cmp %i3, %l0
4000f3e8: 1a bf ff e2 bcc 4000f370 <rtems_blkdev_generic_write+0x60><== ALWAYS TAKEN
4000f3ec: 80 a7 20 00 cmp %i4, 0
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
4000f3f0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000f3f4: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
4000f3f8: 7f ff fd 11 call 4000e83c <rtems_bdbuf_read> <== NOT EXECUTED
4000f3fc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
4000f400: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f404: 02 bf ff e3 be 4000f390 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
4000f408: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
4000f40c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f410: 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;
4000f414: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
4000f418: 81 c7 e0 08 ret
4000f41c: 91 e8 00 08 restore %g0, %o0, %o0
400031e8 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
400031e8: 9d e3 bf a0 save %sp, -96, %sp
400031ec: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv = 0;
400031f0: 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);
400031f4: 40 00 31 be call 4000f8ec <rtems_bdbuf_syncdev>
400031f8: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
400031fc: 80 a2 20 00 cmp %o0, 0
40003200: 12 80 00 04 bne 40003210 <rtems_blkdev_imfs_fsync_or_fdatasync+0x28><== NEVER TAKEN
40003204: 01 00 00 00 nop
errno = EIO;
rv = -1;
}
return rv;
}
40003208: 81 c7 e0 08 ret
4000320c: 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;
40003210: 40 00 44 9c call 40014480 <__errno> <== NOT EXECUTED
40003214: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003218: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000321c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003220: 81 c7 e0 08 ret <== NOT EXECUTED
40003224: 81 e8 00 00 restore <== NOT EXECUTED
40003228 <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
40003228: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
4000322c: 03 30 06 10 sethi %hi(0xc0184000), %g1
40003230: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40003234: 80 a6 40 01 cmp %i1, %g1
40003238: 02 80 00 09 be 4000325c <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
4000323c: 92 10 00 19 mov %i1, %o1
40003240: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40003244: 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);
40003248: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000324c: 9f c0 40 00 call %g1
40003250: 94 10 00 1a mov %i2, %o2
40003254: 81 c7 e0 08 ret
40003258: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
4000325c: 40 00 44 89 call 40014480 <__errno> <== NOT EXECUTED
40003260: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003264: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40003268: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
4000326c: 81 c7 e0 08 ret <== NOT EXECUTED
40003270: 81 e8 00 00 restore <== NOT EXECUTED
4000305c <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000305c: 9d e3 bf 98 save %sp, -104, %sp
40003060: 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;
40003064: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40003068: 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);
4000306c: 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);
40003070: e4 04 60 24 ld [ %l1 + 0x24 ], %l2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40003074: 90 10 00 1c mov %i4, %o0
40003078: a1 3c a0 1f sra %l2, 0x1f, %l0
4000307c: 96 10 00 12 mov %l2, %o3
40003080: 40 00 54 74 call 40018250 <__divdi3>
40003084: 94 10 00 10 mov %l0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
40003088: 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);
4000308c: b6 10 00 09 mov %o1, %i3
ssize_t block_offset = (ssize_t) (offset % block_size);
40003090: 90 10 00 1c mov %i4, %o0
40003094: 92 10 00 1d mov %i5, %o1
40003098: 40 00 55 59 call 400185fc <__moddi3>
4000309c: 96 10 00 12 mov %l2, %o3
char *dst = buffer;
while (remaining > 0) {
400030a0: ba 96 a0 00 orcc %i2, 0, %i5
400030a4: 04 80 00 23 ble 40003130 <rtems_blkdev_imfs_read+0xd4> <== NEVER TAKEN
400030a8: a0 10 00 09 mov %o1, %l0
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
400030ac: 92 10 00 1b mov %i3, %o1
400030b0: 94 07 bf fc add %fp, -4, %o2
400030b4: 40 00 30 df call 4000f430 <rtems_bdbuf_read>
400030b8: 90 10 00 11 mov %l1, %o0
if (sc == RTEMS_SUCCESSFUL) {
400030bc: 80 a2 20 00 cmp %o0, 0
400030c0: 02 80 00 09 be 400030e4 <rtems_blkdev_imfs_read+0x88> <== ALWAYS TAKEN
400030c4: 90 10 00 19 mov %i1, %o0
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
400030c8: 40 00 44 ee call 40014480 <__errno> <== NOT EXECUTED
400030cc: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
400030d0: 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;
400030d4: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
400030d8: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
400030dc: 81 c7 e0 08 ret <== NOT EXECUTED
400030e0: 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;
400030e4: b8 24 80 10 sub %l2, %l0, %i4
400030e8: 80 a7 00 1d cmp %i4, %i5
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
400030ec: 04 80 00 03 ble 400030f8 <rtems_blkdev_imfs_read+0x9c>
400030f0: c2 07 bf fc ld [ %fp + -4 ], %g1
400030f4: b8 10 00 1d mov %i5, %i4
400030f8: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
400030fc: 94 10 00 1c mov %i4, %o2
40003100: 40 00 47 41 call 40014e04 <memcpy>
40003104: 92 02 40 10 add %o1, %l0, %o1
sc = rtems_bdbuf_release(bd);
40003108: d0 07 bf fc ld [ %fp + -4 ], %o0
4000310c: 40 00 31 4e call 4000f644 <rtems_bdbuf_release>
40003110: ba 27 40 1c sub %i5, %i4, %i5
if (sc == RTEMS_SUCCESSFUL) {
40003114: 80 a2 20 00 cmp %o0, 0
40003118: 12 bf ff ec bne 400030c8 <rtems_blkdev_imfs_read+0x6c> <== NEVER TAKEN
4000311c: 80 a7 60 00 cmp %i5, 0
block_offset = 0;
remaining -= copy;
dst += copy;
40003120: b2 06 40 1c add %i1, %i4, %i1
++block;
40003124: 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) {
40003128: 14 bf ff e1 bg 400030ac <rtems_blkdev_imfs_read+0x50>
4000312c: a0 10 20 00 clr %l0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
40003130: 80 a7 60 00 cmp %i5, 0
40003134: 12 bf ff e5 bne 400030c8 <rtems_blkdev_imfs_read+0x6c> <== NEVER TAKEN
40003138: 82 10 00 1a mov %i2, %g1
iop->offset += count;
4000313c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40003140: 86 80 c0 1a addcc %g3, %i2, %g3
40003144: 84 40 a0 00 addx %g2, 0, %g2
40003148: c4 3e 20 08 std %g2, [ %i0 + 8 ]
errno = EIO;
rv = -1;
}
return rv;
}
4000314c: 81 c7 e0 08 ret
40003150: 91 e8 00 01 restore %g0, %g1, %o0
40002f28 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
40002f28: 9d e3 bf 98 save %sp, -104, %sp
40002f2c: 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;
40002f30: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40002f34: 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);
40002f38: 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);
40002f3c: f6 04 60 24 ld [ %l1 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40002f40: 90 10 00 1c mov %i4, %o0
40002f44: a1 3e e0 1f sra %i3, 0x1f, %l0
40002f48: 96 10 00 1b mov %i3, %o3
40002f4c: 40 00 54 c1 call 40018250 <__divdi3>
40002f50: 94 10 00 10 mov %l0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
40002f54: 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);
40002f58: a4 10 00 09 mov %o1, %l2
ssize_t block_offset = (ssize_t) (offset % block_size);
40002f5c: 90 10 00 1c mov %i4, %o0
40002f60: 92 10 00 1d mov %i5, %o1
40002f64: 40 00 55 a6 call 400185fc <__moddi3>
40002f68: 96 10 00 1b mov %i3, %o3
const char *src = buffer;
while (remaining > 0) {
40002f6c: ba 96 a0 00 orcc %i2, 0, %i5
40002f70: 04 80 00 2e ble 40003028 <rtems_blkdev_imfs_write+0x100> <== NEVER TAKEN
40002f74: a0 10 00 09 mov %o1, %l0
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
40002f78: 80 a7 40 1b cmp %i5, %i3
40002f7c: 16 80 00 03 bge 40002f88 <rtems_blkdev_imfs_write+0x60>
40002f80: 82 10 20 01 mov 1, %g1
40002f84: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
40002f88: 90 10 00 11 mov %l1, %o0
40002f8c: 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) {
40002f90: 80 88 60 ff btst 0xff, %g1
40002f94: 02 80 00 2e be 4000304c <rtems_blkdev_imfs_write+0x124>
40002f98: 94 07 bf fc add %fp, -4, %o2
40002f9c: 80 a4 20 00 cmp %l0, 0
40002fa0: 12 80 00 2b bne 4000304c <rtems_blkdev_imfs_write+0x124>
40002fa4: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
40002fa8: 40 00 30 e2 call 4000f330 <rtems_bdbuf_get>
40002fac: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
40002fb0: 80 a2 20 00 cmp %o0, 0
40002fb4: 02 80 00 09 be 40002fd8 <rtems_blkdev_imfs_write+0xb0> <== ALWAYS TAKEN
40002fb8: b8 26 c0 10 sub %i3, %l0, %i4
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
40002fbc: 40 00 45 31 call 40014480 <__errno> <== NOT EXECUTED
40002fc0: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
40002fc4: 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;
40002fc8: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
40002fcc: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40002fd0: 81 c7 e0 08 ret <== NOT EXECUTED
40002fd4: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
40002fd8: 80 a7 00 1d cmp %i4, %i5
40002fdc: 34 80 00 02 bg,a 40002fe4 <rtems_blkdev_imfs_write+0xbc>
40002fe0: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
40002fe4: c2 07 bf fc ld [ %fp + -4 ], %g1
40002fe8: 92 10 00 19 mov %i1, %o1
40002fec: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40002ff0: 94 10 00 1c mov %i4, %o2
40002ff4: 40 00 47 84 call 40014e04 <memcpy>
40002ff8: 90 02 00 10 add %o0, %l0, %o0
sc = rtems_bdbuf_release_modified(bd);
40002ffc: 40 00 31 ca call 4000f724 <rtems_bdbuf_release_modified>
40003000: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
40003004: 80 a2 20 00 cmp %o0, 0
40003008: 12 bf ff ed bne 40002fbc <rtems_blkdev_imfs_write+0x94> <== NEVER TAKEN
4000300c: 01 00 00 00 nop
block_offset = 0;
remaining -= copy;
40003010: ba 27 40 1c sub %i5, %i4, %i5
src += copy;
40003014: b2 06 40 1c add %i1, %i4, %i1
++block;
40003018: 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) {
4000301c: 80 a7 60 00 cmp %i5, 0
40003020: 14 bf ff d6 bg 40002f78 <rtems_blkdev_imfs_write+0x50>
40003024: a0 10 20 00 clr %l0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
40003028: 80 a7 60 00 cmp %i5, 0
4000302c: 12 bf ff e4 bne 40002fbc <rtems_blkdev_imfs_write+0x94> <== NEVER TAKEN
40003030: 82 10 00 1a mov %i2, %g1
iop->offset += count;
40003034: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40003038: 86 80 c0 1a addcc %g3, %i2, %g3
4000303c: 84 40 a0 00 addx %g2, 0, %g2
40003040: c4 3e 20 08 std %g2, [ %i0 + 8 ]
errno = EIO;
rv = -1;
}
return rv;
}
40003044: 81 c7 e0 08 ret
40003048: 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);
4000304c: 40 00 30 f9 call 4000f430 <rtems_bdbuf_read>
40003050: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
40003054: 10 bf ff d8 b 40002fb4 <rtems_blkdev_imfs_write+0x8c>
40003058: 80 a2 20 00 cmp %o0, 0
4000f0b4 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000f0b4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
4000f0b8: 05 10 01 10 sethi %hi(0x40044000), %g2
4000f0bc: 82 10 a2 03 or %g2, 0x203, %g1 ! 40044203 <__end+0x28403>
4000f0c0: 80 a6 40 01 cmp %i1, %g1
4000f0c4: 22 80 00 55 be,a 4000f218 <rtems_blkdev_ioctl+0x164>
4000f0c8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000f0cc: 08 80 00 1c bleu 4000f13c <rtems_blkdev_ioctl+0x88>
4000f0d0: 03 08 00 10 sethi %hi(0x20004000), %g1
4000f0d4: 82 10 a2 09 or %g2, 0x209, %g1
4000f0d8: 80 a6 40 01 cmp %i1, %g1
4000f0dc: 22 80 00 3c be,a 4000f1cc <rtems_blkdev_ioctl+0x118>
4000f0e0: f0 26 80 00 st %i0, [ %i2 ]
4000f0e4: 28 80 00 27 bleu,a 4000f180 <rtems_blkdev_ioctl+0xcc>
4000f0e8: 84 10 a2 05 or %g2, 0x205, %g2
4000f0ec: 84 10 a2 0b or %g2, 0x20b, %g2
4000f0f0: 80 a6 40 02 cmp %i1, %g2
4000f0f4: 02 80 00 3f be 4000f1f0 <rtems_blkdev_ioctl+0x13c>
4000f0f8: 03 20 01 10 sethi %hi(0x80044000), %g1
4000f0fc: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <LEON_REG+0x44204>
4000f100: 80 a6 40 01 cmp %i1, %g1
4000f104: 12 80 00 22 bne 4000f18c <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
4000f108: 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);
4000f10c: d2 06 80 00 ld [ %i2 ], %o1
4000f110: 7f ff ff 8f call 4000ef4c <rtems_bdbuf_set_block_size>
4000f114: 94 10 20 01 mov 1, %o2
if (sc != RTEMS_SUCCESSFUL) {
4000f118: 80 a2 20 00 cmp %o0, 0
4000f11c: 02 80 00 2a be 4000f1c4 <rtems_blkdev_ioctl+0x110> <== ALWAYS TAKEN
4000f120: 01 00 00 00 nop
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
errno = EIO;
4000f124: 40 00 13 3c call 40013e14 <__errno> <== NOT EXECUTED
4000f128: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4000f12c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000f130: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000f134: 81 c7 e0 08 ret <== NOT EXECUTED
4000f138: 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)
4000f13c: 86 10 62 0a or %g1, 0x20a, %g3
4000f140: 80 a6 40 03 cmp %i1, %g3
4000f144: 02 80 00 31 be 4000f208 <rtems_blkdev_ioctl+0x154>
4000f148: 90 10 00 18 mov %i0, %o0
4000f14c: 28 80 00 16 bleu,a 4000f1a4 <rtems_blkdev_ioctl+0xf0>
4000f150: 82 10 62 06 or %g1, 0x206, %g1
4000f154: 82 10 62 0c or %g1, 0x20c, %g1
4000f158: 80 a6 40 01 cmp %i1, %g1
4000f15c: 02 80 00 21 be 4000f1e0 <rtems_blkdev_ioctl+0x12c>
4000f160: 84 10 a2 02 or %g2, 0x202, %g2
4000f164: 80 a6 40 02 cmp %i1, %g2
4000f168: 12 80 00 09 bne 4000f18c <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
4000f16c: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
4000f170: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000f174: c2 26 80 00 st %g1, [ %i2 ]
break;
4000f178: 81 c7 e0 08 ret
4000f17c: 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)
4000f180: 80 a6 40 02 cmp %i1, %g2
4000f184: 22 80 00 14 be,a 4000f1d4 <rtems_blkdev_ioctl+0x120> <== ALWAYS TAKEN
4000f188: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
break;
default:
errno = EINVAL;
4000f18c: 40 00 13 22 call 40013e14 <__errno>
4000f190: b0 10 3f ff mov -1, %i0
4000f194: 82 10 20 16 mov 0x16, %g1
4000f198: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
break;
}
return rc;
}
4000f19c: 81 c7 e0 08 ret
4000f1a0: 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)
4000f1a4: 80 a6 40 01 cmp %i1, %g1
4000f1a8: 12 bf ff f9 bne 4000f18c <rtems_blkdev_ioctl+0xd8>
4000f1ac: 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);
4000f1b0: 7f ff fe d2 call 4000ecf8 <rtems_bdbuf_syncdev>
4000f1b4: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL) {
4000f1b8: 80 a2 20 00 cmp %o0, 0
4000f1bc: 12 bf ff da bne 4000f124 <rtems_blkdev_ioctl+0x70> <== NEVER TAKEN
4000f1c0: 01 00 00 00 nop
}
break;
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
4000f1c4: 81 c7 e0 08 ret
4000f1c8: 91 e8 20 00 restore %g0, 0, %o0
4000f1cc: 81 c7 e0 08 ret
4000f1d0: 91 e8 20 00 restore %g0, 0, %o0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
4000f1d4: c2 26 80 00 st %g1, [ %i2 ]
break;
4000f1d8: 81 c7 e0 08 ret
4000f1dc: 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);
4000f1e0: 7f ff ff ac call 4000f090 <rtems_bdbuf_reset_device_stats>
4000f1e4: b0 10 20 00 clr %i0
break;
4000f1e8: 81 c7 e0 08 ret
4000f1ec: 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);
4000f1f0: 90 10 00 18 mov %i0, %o0
4000f1f4: 92 10 00 1a mov %i2, %o1
4000f1f8: 7f ff ff 9d call 4000f06c <rtems_bdbuf_get_device_stats>
4000f1fc: b0 10 20 00 clr %i0
break;
4000f200: 81 c7 e0 08 ret
4000f204: 81 e8 00 00 restore
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
4000f208: 7f ff fe d3 call 4000ed54 <rtems_bdbuf_purge_dev>
4000f20c: b0 10 20 00 clr %i0
break;
4000f210: 81 c7 e0 08 ret
4000f214: 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;
4000f218: c2 26 80 00 st %g1, [ %i2 ]
break;
4000f21c: 81 c7 e0 08 ret
4000f220: 91 e8 20 00 restore %g0, 0, %o0
40024d74 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
40024d74: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
40024d78: 92 10 20 00 clr %o1 <== NOT EXECUTED
40024d7c: 7f ff 7a 74 call 4000374c <open> <== NOT EXECUTED
40024d80: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
40024d84: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40024d88: 06 80 00 33 bl 40024e54 <rtems_blkstats+0xe0> <== NOT EXECUTED
40024d8c: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
40024d90: 40 00 07 90 call 40026bd0 <fstat> <== NOT EXECUTED
40024d94: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
40024d98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40024d9c: 12 80 00 39 bne 40024e80 <rtems_blkstats+0x10c> <== NOT EXECUTED
40024da0: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
40024da4: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
40024da8: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
40024dac: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
40024db0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40024db4: 02 80 00 19 be 40024e18 <rtems_blkstats+0xa4> <== NOT EXECUTED
40024db8: 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");
40024dbc: 11 10 01 7a sethi %hi(0x4005e800), %o0 <== NOT EXECUTED
40024dc0: 90 12 20 70 or %o0, 0x70, %o0 ! 4005e870 <RTEMS_BDPART_MBR_MASTER_TYPE+0x40><== NOT EXECUTED
40024dc4: 94 10 20 1a mov 0x1a, %o2 <== NOT EXECUTED
40024dc8: 40 00 61 67 call 4003d364 <fwrite> <== NOT EXECUTED
40024dcc: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
}
rv = close(fd);
40024dd0: 40 00 06 5f call 4002674c <close> <== NOT EXECUTED
40024dd4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
40024dd8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40024ddc: 12 80 00 04 bne 40024dec <rtems_blkstats+0x78> <== NOT EXECUTED
40024de0: 01 00 00 00 nop <== NOT EXECUTED
40024de4: 81 c7 e0 08 ret <== NOT EXECUTED
40024de8: 81 e8 00 00 restore <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
40024dec: 40 00 59 df call 4003b568 <__errno> <== NOT EXECUTED
40024df0: 01 00 00 00 nop <== NOT EXECUTED
40024df4: 40 00 75 84 call 40042404 <strerror> <== NOT EXECUTED
40024df8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40024dfc: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40024e00: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40024e04: 92 12 60 b0 or %o1, 0xb0, %o1 <== NOT EXECUTED
40024e08: 40 00 5c 9b call 4003c074 <fprintf> <== NOT EXECUTED
40024e0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024e10: 81 c7 e0 08 ret <== NOT EXECUTED
40024e14: 81 e8 00 00 restore <== NOT EXECUTED
int rv;
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
40024e18: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40024e1c: 12 80 00 23 bne 40024ea8 <rtems_blkstats+0x134> <== NOT EXECUTED
40024e20: 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);
40024e24: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
40024e28: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
40024e2c: 40 00 0a 4d call 40027760 <ioctl> <== NOT EXECUTED
40024e30: 92 12 62 0b or %o1, 0x20b, %o1 ! 4004420b <_svfprintf_r+0x283><== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
40024e34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40024e38: 12 80 00 2c bne 40024ee8 <rtems_blkstats+0x174> <== NOT EXECUTED
40024e3c: 13 10 00 f0 sethi %hi(0x4003c000), %o1 <== NOT EXECUTED
rtems_blkdev_print_stats(
40024e40: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
40024e44: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40024e48: 40 00 00 32 call 40024f10 <rtems_blkdev_print_stats> <== NOT EXECUTED
40024e4c: 92 12 60 74 or %o1, 0x74, %o1 <== NOT EXECUTED
40024e50: 30 bf ff e0 b,a 40024dd0 <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));
40024e54: 40 00 59 c5 call 4003b568 <__errno> <== NOT EXECUTED
40024e58: 01 00 00 00 nop <== NOT EXECUTED
40024e5c: 40 00 75 6a call 40042404 <strerror> <== NOT EXECUTED
40024e60: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40024e64: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40024e68: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40024e6c: 92 12 60 d0 or %o1, 0xd0, %o1 <== NOT EXECUTED
40024e70: 40 00 5c 81 call 4003c074 <fprintf> <== NOT EXECUTED
40024e74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024e78: 81 c7 e0 08 ret <== NOT EXECUTED
40024e7c: 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));
40024e80: 40 00 59 ba call 4003b568 <__errno> <== NOT EXECUTED
40024e84: 01 00 00 00 nop <== NOT EXECUTED
40024e88: 40 00 75 5f call 40042404 <strerror> <== NOT EXECUTED
40024e8c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40024e90: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40024e94: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40024e98: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED
40024e9c: 40 00 5c 76 call 4003c074 <fprintf> <== NOT EXECUTED
40024ea0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024ea4: 30 bf ff cb b,a 40024dd0 <rtems_blkstats+0x5c> <== NOT EXECUTED
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
40024ea8: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
40024eac: 40 00 0a 2d call 40027760 <ioctl> <== NOT EXECUTED
40024eb0: 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) {
40024eb4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40024eb8: 02 bf ff c6 be 40024dd0 <rtems_blkstats+0x5c> <== NOT EXECUTED
40024ebc: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
40024ec0: 40 00 59 aa call 4003b568 <__errno> <== NOT EXECUTED
40024ec4: 01 00 00 00 nop <== NOT EXECUTED
40024ec8: 40 00 75 4f call 40042404 <strerror> <== NOT EXECUTED
40024ecc: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40024ed0: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40024ed4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40024ed8: 92 12 60 40 or %o1, 0x40, %o1 <== NOT EXECUTED
40024edc: 40 00 5c 66 call 4003c074 <fprintf> <== NOT EXECUTED
40024ee0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024ee4: 30 bf ff bb b,a 40024dd0 <rtems_blkstats+0x5c> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
40024ee8: 40 00 59 a0 call 4003b568 <__errno> <== NOT EXECUTED
40024eec: 01 00 00 00 nop <== NOT EXECUTED
40024ef0: 40 00 75 45 call 40042404 <strerror> <== NOT EXECUTED
40024ef4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40024ef8: 13 10 01 7a sethi %hi(0x4005e800), %o1 <== NOT EXECUTED
40024efc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40024f00: 92 12 60 58 or %o1, 0x58, %o1 <== NOT EXECUTED
40024f04: 40 00 5c 5c call 4003c074 <fprintf> <== NOT EXECUTED
40024f08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40024f0c: 30 bf ff b1 b,a 40024dd0 <rtems_blkstats+0x5c> <== NOT EXECUTED
40002830 <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
40002830: 9d e3 bf a0 save %sp, -96, %sp
const char *p;
if ( !name )
40002834: 80 a6 20 00 cmp %i0, 0
40002838: 02 80 00 36 be 40002910 <rtems_bsp_cmdline_get_param+0xe0>
4000283c: 80 a6 60 00 cmp %i1, 0
return NULL;
if ( !value )
40002840: 02 80 00 34 be 40002910 <rtems_bsp_cmdline_get_param+0xe0>
40002844: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( !length )
40002848: 22 80 00 33 be,a 40002914 <rtems_bsp_cmdline_get_param+0xe4>
4000284c: b2 10 20 00 clr %i1
return NULL;
value[0] = '\0';
40002850: c0 2e 40 00 clrb [ %i1 ]
p = rtems_bsp_cmdline_get_param_raw( name );
40002854: 40 00 00 32 call 4000291c <rtems_bsp_cmdline_get_param_raw>
40002858: 90 10 00 18 mov %i0, %o0
if ( !p )
4000285c: 80 a2 20 00 cmp %o0, 0
40002860: 22 80 00 2d be,a 40002914 <rtems_bsp_cmdline_get_param+0xe4>
40002864: b2 10 20 00 clr %i1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40002868: c6 0a 00 00 ldub [ %o0 ], %g3
4000286c: 85 28 e0 18 sll %g3, 0x18, %g2
40002870: 80 a0 a0 00 cmp %g2, 0
40002874: 02 80 00 25 be 40002908 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40002878: 80 a6 a0 01 cmp %i2, 1
4000287c: 02 80 00 23 be 40002908 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40002880: b4 06 bf ff add %i2, -1, %i2
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
40002884: 82 10 20 00 clr %g1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40002888: 88 10 20 00 clr %g4
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
4000288c: 10 80 00 12 b 400028d4 <rtems_bsp_cmdline_get_param+0xa4>
40002890: ba 10 20 00 clr %i5
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
40002894: 32 80 00 06 bne,a 400028ac <rtems_bsp_cmdline_get_param+0x7c>
40002898: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
4000289c: 80 a0 a0 20 cmp %g2, 0x20
400028a0: 02 80 00 1a be 40002908 <rtems_bsp_cmdline_get_param+0xd8>
400028a4: 01 00 00 00 nop
break;
value[i++] = *p++;
400028a8: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
400028ac: 82 00 60 01 inc %g1
value[i] = '\0';
400028b0: c0 2e 40 01 clrb [ %i1 + %g1 ]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
400028b4: c6 0a 00 01 ldub [ %o0 + %g1 ], %g3
400028b8: 85 28 e0 18 sll %g3, 0x18, %g2
400028bc: 80 a0 a0 00 cmp %g2, 0
400028c0: 02 80 00 12 be 40002908 <rtems_bsp_cmdline_get_param+0xd8>
400028c4: 88 10 00 01 mov %g1, %g4
400028c8: 80 a0 40 1a cmp %g1, %i2
400028cc: 02 80 00 0f be 40002908 <rtems_bsp_cmdline_get_param+0xd8>
400028d0: 01 00 00 00 nop
if ( *p == '\"' ) {
400028d4: 85 38 a0 18 sra %g2, 0x18, %g2
400028d8: 80 a0 a0 22 cmp %g2, 0x22
400028dc: 12 bf ff ee bne 40002894 <rtems_bsp_cmdline_get_param+0x64>
400028e0: 80 8f 60 01 btst 1, %i5
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
400028e4: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
400028e8: 82 00 60 01 inc %g1
value[i] = '\0';
400028ec: c0 2e 40 01 clrb [ %i1 + %g1 ]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
400028f0: c6 0a 00 01 ldub [ %o0 + %g1 ], %g3
if ( *p == '\"' ) {
quotes++;
400028f4: ba 07 60 01 inc %i5
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
400028f8: 85 28 e0 18 sll %g3, 0x18, %g2
400028fc: 80 a0 a0 00 cmp %g2, 0
40002900: 12 bf ff f2 bne 400028c8 <rtems_bsp_cmdline_get_param+0x98><== ALWAYS TAKEN
40002904: 88 10 00 01 mov %g1, %g4
return NULL;
copy_string( p, value, length );
return value;
}
40002908: 81 c7 e0 08 ret
4000290c: 91 e8 00 19 restore %g0, %i1, %o0
)
{
const char *p;
if ( !name )
return NULL;
40002910: b2 10 20 00 clr %i1
return NULL;
copy_string( p, value, length );
return value;
}
40002914: 81 c7 e0 08 ret
40002918: 91 e8 00 19 restore %g0, %i1, %o0
40007d10 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
40007d10: 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 );
40007d14: 40 00 01 a1 call 40008398 <_Chain_Get>
40007d18: 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(
40007d1c: 92 10 20 00 clr %o1
40007d20: ba 10 00 08 mov %o0, %i5
40007d24: 94 10 00 1a mov %i2, %o2
40007d28: 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
40007d2c: 80 a7 60 00 cmp %i5, 0
40007d30: 12 80 00 0a bne 40007d58 <rtems_chain_get_with_wait+0x48>
40007d34: 96 07 bf fc add %fp, -4, %o3
) {
rtems_event_set out;
sc = rtems_event_receive(
40007d38: 7f ff fc df call 400070b4 <rtems_event_receive>
40007d3c: 01 00 00 00 nop
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
40007d40: 80 a2 20 00 cmp %o0, 0
40007d44: 02 bf ff f4 be 40007d14 <rtems_chain_get_with_wait+0x4> <== NEVER TAKEN
40007d48: 01 00 00 00 nop
timeout,
&out
);
}
*node_ptr = node;
40007d4c: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
40007d50: 81 c7 e0 08 ret
40007d54: 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
40007d58: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
40007d5c: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
40007d60: 81 c7 e0 08 ret
40007d64: 91 e8 00 08 restore %g0, %o0, %o0
40003304 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40003304: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
40003308: 80 a6 60 00 cmp %i1, 0
4000330c: 02 80 00 85 be 40003520 <rtems_cpu_usage_report_with_plugin+0x21c><== NEVER TAKEN
40003310: 03 10 00 88 sethi %hi(0x40022000), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
40003314: c0 27 bf e0 clr [ %fp + -32 ]
40003318: c0 27 bf e4 clr [ %fp + -28 ]
}
}
}
#endif
(*print)(
4000331c: 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;
40003320: f8 18 60 a0 ldd [ %g1 + 0xa0 ], %i4
}
}
}
#endif
(*print)(
40003324: 13 10 00 7b sethi %hi(0x4001ec00), %o1
40003328: 2b 10 00 86 sethi %hi(0x40021800), %l5
4000332c: 92 12 61 b0 or %o1, 0x1b0, %o1
40003330: aa 15 62 58 or %l5, 0x258, %l5
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40003334: 25 10 00 7b sethi %hi(0x4001ec00), %l2
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40003338: 29 10 00 86 sethi %hi(0x40021800), %l4
}
}
}
#endif
(*print)(
4000333c: 9f c6 40 00 call %i1
40003340: 27 10 00 7b sethi %hi(0x4001ec00), %l3
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
40003344: ac 05 60 0c add %l5, 0xc, %l6
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40003348: a4 14 a3 28 or %l2, 0x328, %l2
4000334c: a8 15 22 40 or %l4, 0x240, %l4
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
40003350: a6 14 e3 40 or %l3, 0x340, %l3
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
40003354: c2 05 40 00 ld [ %l5 ], %g1
40003358: e2 00 60 04 ld [ %g1 + 4 ], %l1
if ( information ) {
4000335c: 80 a4 60 00 cmp %l1, 0
40003360: 22 80 00 56 be,a 400034b8 <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
40003364: aa 05 60 04 add %l5, 4, %l5 <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
40003368: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1
4000336c: 86 90 60 00 orcc %g1, 0, %g3
40003370: 02 80 00 51 be 400034b4 <rtems_cpu_usage_report_with_plugin+0x1b0>
40003374: a0 10 20 01 mov 1, %l0
the_thread = (Thread_Control *)information->local_table[ i ];
40003378: 10 80 00 2d b 4000342c <rtems_cpu_usage_report_with_plugin+0x128>
4000337c: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
40003380: 90 07 bf d8 add %fp, -40, %o0
40003384: 40 00 19 ca call 40009aac <_TOD_Get_with_nanoseconds>
40003388: 92 10 00 14 mov %l4, %o1
4000338c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40003390: 86 a0 c0 1d subcc %g3, %i5, %g3
40003394: 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 );
40003398: 90 07 bf e8 add %fp, -24, %o0
4000339c: c4 3f bf e0 std %g2, [ %fp + -32 ]
400033a0: 92 07 bf e0 add %fp, -32, %o1
400033a4: 94 07 bf d0 add %fp, -48, %o2
400033a8: 40 00 23 a2 call 4000c230 <_Timestamp64_Divide>
400033ac: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
400033b0: 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);
400033b4: 94 10 20 00 clr %o2
400033b8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400033bc: 90 10 00 1a mov %i2, %o0
400033c0: 96 12 e2 00 or %o3, 0x200, %o3
400033c4: 40 00 5e ef call 4001af80 <__divdi3>
400033c8: 92 10 00 1b mov %i3, %o1
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400033cc: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400033d0: ae 10 00 09 mov %o1, %l7
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400033d4: 90 10 00 1a mov %i2, %o0
400033d8: 92 10 00 1b mov %i3, %o1
400033dc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400033e0: 40 00 5f d3 call 4001b32c <__moddi3>
400033e4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
400033e8: 90 10 00 09 mov %o1, %o0
400033ec: 40 00 5d 8d call 4001aa20 <.udiv>
400033f0: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400033f4: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
400033f8: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400033fc: 92 10 00 13 mov %l3, %o1
40003400: 90 10 00 18 mov %i0, %o0
40003404: 9f c6 40 00 call %i1
40003408: 94 10 00 17 mov %l7, %o2
4000340c: 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++ ) {
40003410: a0 04 20 01 inc %l0
40003414: 83 28 e0 10 sll %g3, 0x10, %g1
40003418: 83 30 60 10 srl %g1, 0x10, %g1
4000341c: 80 a0 40 10 cmp %g1, %l0
40003420: 2a 80 00 26 bcs,a 400034b8 <rtems_cpu_usage_report_with_plugin+0x1b4>
40003424: aa 05 60 04 add %l5, 4, %l5
the_thread = (Thread_Control *)information->local_table[ i ];
40003428: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
4000342c: 83 2c 20 02 sll %l0, 2, %g1
40003430: f6 00 80 01 ld [ %g2 + %g1 ], %i3
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40003434: 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 )
40003438: 80 a6 e0 00 cmp %i3, 0
4000343c: 02 bf ff f5 be 40003410 <rtems_cpu_usage_report_with_plugin+0x10c><== NEVER TAKEN
40003440: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40003444: 40 00 14 2d call 400084f8 <rtems_object_get_name>
40003448: d0 06 e0 08 ld [ %i3 + 8 ], %o0
(*print)(
4000344c: d4 06 e0 08 ld [ %i3 + 8 ], %o2
40003450: 90 10 00 18 mov %i0, %o0
40003454: 92 10 00 12 mov %l2, %o1
40003458: 9f c6 40 00 call %i1
4000345c: 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 ) {
40003460: 03 10 00 88 sethi %hi(0x40022000), %g1
40003464: 82 10 60 40 or %g1, 0x40, %g1 ! 40022040 <_Per_CPU_Information>
40003468: 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;
4000346c: 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 ) {
40003470: f4 01 20 08 ld [ %g4 + 8 ], %i2
40003474: c8 06 e0 08 ld [ %i3 + 8 ], %g4
40003478: 80 a6 80 04 cmp %i2, %g4
4000347c: 12 bf ff c1 bne 40003380 <rtems_cpu_usage_report_with_plugin+0x7c>
40003480: c4 3f bf e8 std %g2, [ %fp + -24 ]
*time_of_context_switch = _Thread_Time_of_last_context_switch;
40003484: f4 18 60 20 ldd [ %g1 + 0x20 ], %i2
40003488: 92 10 00 14 mov %l4, %o1
4000348c: 40 00 19 88 call 40009aac <_TOD_Get_with_nanoseconds>
40003490: 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 );
40003494: c4 1f bf d8 ldd [ %fp + -40 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40003498: 96 a0 c0 1b subcc %g3, %i3, %o3
4000349c: 94 60 80 1a subx %g2, %i2, %o2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
400034a0: f4 1f bf e8 ldd [ %fp + -24 ], %i2
400034a4: 9a 86 c0 0b addcc %i3, %o3, %o5
400034a8: 98 46 80 0a addx %i2, %o2, %o4
400034ac: 10 bf ff b9 b 40003390 <rtems_cpu_usage_report_with_plugin+0x8c>
400034b0: d8 3f bf e8 std %o4, [ %fp + -24 ]
400034b4: 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++ ) {
400034b8: 80 a5 40 16 cmp %l5, %l6
400034bc: 32 bf ff a7 bne,a 40003358 <rtems_cpu_usage_report_with_plugin+0x54>
400034c0: c2 05 40 00 ld [ %l5 ], %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
400034c4: 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);
400034c8: 94 10 20 00 clr %o2
400034cc: 90 10 00 1c mov %i4, %o0
400034d0: 92 10 00 1d mov %i5, %o1
400034d4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400034d8: 40 00 5e aa call 4001af80 <__divdi3>
400034dc: 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);
400034e0: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400034e4: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400034e8: 90 10 00 1c mov %i4, %o0
400034ec: 92 10 00 1d mov %i5, %o1
400034f0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400034f4: 40 00 5f 8e call 4001b32c <__moddi3>
400034f8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
400034fc: 90 10 00 09 mov %o1, %o0
40003500: 40 00 5d 48 call 4001aa20 <.udiv>
40003504: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
40003508: 94 10 00 1b mov %i3, %o2
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
4000350c: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
40003510: 13 10 00 7b sethi %hi(0x4001ec00), %o1
40003514: 90 10 00 18 mov %i0, %o0
40003518: 9f c6 40 00 call %i1
4000351c: 92 12 63 58 or %o1, 0x358, %o1
40003520: 81 c7 e0 08 ret
40003524: 81 e8 00 00 restore
4000f654 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
4000f654: 9d e3 bf a0 save %sp, -96, %sp
4000f658: 82 10 00 18 mov %i0, %g1
if (sc == RTEMS_SUCCESSFUL) {
4000f65c: 80 a0 60 00 cmp %g1, 0
4000f660: 02 80 00 0c be 4000f690 <rtems_deviceio_errno+0x3c>
4000f664: b0 10 20 00 clr %i0
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4000f668: 80 a0 60 1c cmp %g1, 0x1c
4000f66c: 18 80 00 06 bgu 4000f684 <rtems_deviceio_errno+0x30> <== NEVER TAKEN
4000f670: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
4000f674: 83 28 60 02 sll %g1, 2, %g1
4000f678: 05 10 00 75 sethi %hi(0x4001d400), %g2
4000f67c: 84 10 a1 b4 or %g2, 0x1b4, %g2 ! 4001d5b4 <status_code_to_errno>
4000f680: fa 00 80 01 ld [ %g2 + %g1 ], %i5
}
errno = eno;
4000f684: 40 00 00 2f call 4000f740 <__errno>
4000f688: b0 10 3f ff mov -1, %i0
4000f68c: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
4000f690: 81 c7 e0 08 ret
4000f694: 81 e8 00 00 restore
40003314 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
40003314: 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;
40003318: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
4000331c: 7f ff fe f5 call 40002ef0 <disk_lock>
40003320: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
40003324: a0 92 20 00 orcc %o0, 0, %l0
40003328: 02 80 00 04 be 40003338 <rtems_disk_create_log+0x24> <== ALWAYS TAKEN
4000332c: 92 10 00 1b mov %i3, %o1
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
40003330: 81 c7 e0 08 ret <== NOT EXECUTED
40003334: 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);
40003338: 90 10 00 1a mov %i2, %o0
4000333c: 7f ff fe b0 call 40002dfc <get_disk_entry>
40003340: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
40003344: b6 92 20 00 orcc %o0, 0, %i3
40003348: 02 80 00 25 be 400033dc <rtems_disk_create_log+0xc8>
4000334c: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
40003350: 90 10 00 18 mov %i0, %o0
40003354: 92 10 00 19 mov %i1, %o1
40003358: 96 07 bf f8 add %fp, -8, %o3
4000335c: 7f ff ff 03 call 40002f68 <create_disk>
40003360: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
40003364: a0 92 20 00 orcc %o0, 0, %l0
40003368: 12 80 00 19 bne 400033cc <rtems_disk_create_log+0xb8>
4000336c: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
40003370: 92 10 00 1b mov %i3, %o1
40003374: 94 10 00 1c mov %i4, %o2
40003378: 40 00 30 bc call 4000f668 <rtems_disk_init_log>
4000337c: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
40003380: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
++phys_dd->uses;
40003384: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
block_begin,
block_count
);
dd->dev = dev;
dd->name = alloc_name;
40003388: c6 07 bf fc ld [ %fp + -4 ], %g3
++phys_dd->uses;
4000338c: 84 00 a0 01 inc %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
40003390: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
40003394: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
++phys_dd->uses;
40003398: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
if (sc != RTEMS_SUCCESSFUL) {
4000339c: 80 a2 20 00 cmp %o0, 0
400033a0: 02 80 00 0b be 400033cc <rtems_disk_create_log+0xb8>
400033a4: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
400033a8: 05 10 00 0b sethi %hi(0x40002c00), %g2
400033ac: 84 10 a2 90 or %g2, 0x290, %g2 ! 40002e90 <null_handler>
rtems_disk_delete(dev);
400033b0: 92 10 00 19 mov %i1, %o1
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
400033b4: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
400033b8: 7f ff ff 5c call 40003128 <rtems_disk_delete>
400033bc: 90 10 00 18 mov %i0, %o0
disk_unlock();
400033c0: 7f ff fe db call 40002f2c <disk_unlock>
400033c4: b0 10 00 10 mov %l0, %i0
400033c8: 30 80 00 03 b,a 400033d4 <rtems_disk_create_log+0xc0>
return sc;
}
disk_unlock();
400033cc: 7f ff fe d8 call 40002f2c <disk_unlock>
400033d0: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
400033d4: 81 c7 e0 08 ret
400033d8: 81 e8 00 00 restore
return sc;
}
phys_dd = get_disk_entry(phys, true);
if (phys_dd == NULL) {
disk_unlock();
400033dc: 7f ff fe d4 call 40002f2c <disk_unlock>
400033e0: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
400033e4: 81 c7 e0 08 ret
400033e8: 91 e8 00 10 restore %g0, %l0, %o0
400033ec <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
400033ec: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
400033f0: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
400033f4: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
400033f8: 80 a7 20 00 cmp %i4, 0
400033fc: 02 80 00 07 be 40003418 <rtems_disk_create_phys+0x2c>
40003400: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
40003404: 7f ff fe bb call 40002ef0 <disk_lock>
40003408: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
4000340c: a0 92 20 00 orcc %o0, 0, %l0
40003410: 02 80 00 04 be 40003420 <rtems_disk_create_phys+0x34> <== ALWAYS TAKEN
40003414: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
40003418: 81 c7 e0 08 ret
4000341c: 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);
40003420: 90 10 00 18 mov %i0, %o0
40003424: 92 10 00 19 mov %i1, %o1
40003428: 96 07 bf f8 add %fp, -8, %o3
4000342c: 7f ff fe cf call 40002f68 <create_disk>
40003430: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
40003434: a0 92 20 00 orcc %o0, 0, %l0
40003438: 12 80 00 0e bne 40003470 <rtems_disk_create_phys+0x84>
4000343c: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
40003440: 92 10 00 1a mov %i2, %o1
40003444: 94 10 00 1b mov %i3, %o2
40003448: 96 10 00 1c mov %i4, %o3
4000344c: 40 00 30 6d call 4000f600 <rtems_disk_init_phys>
40003450: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
40003454: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
40003458: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
4000345c: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
40003460: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
40003464: 80 a2 20 00 cmp %o0, 0
40003468: 12 80 00 06 bne 40003480 <rtems_disk_create_phys+0x94>
4000346c: a0 10 00 08 mov %o0, %l0
disk_unlock();
return sc;
}
disk_unlock();
40003470: 7f ff fe af call 40002f2c <disk_unlock>
40003474: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
40003478: 81 c7 e0 08 ret
4000347c: 81 e8 00 00 restore
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
40003480: 05 10 00 0b sethi %hi(0x40002c00), %g2
40003484: 84 10 a2 90 or %g2, 0x290, %g2 ! 40002e90 <null_handler>
rtems_disk_delete(dev);
40003488: 92 10 00 19 mov %i1, %o1
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
4000348c: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
40003490: 7f ff ff 26 call 40003128 <rtems_disk_delete>
40003494: 90 10 00 18 mov %i0, %o0
disk_unlock();
40003498: 7f ff fe a5 call 40002f2c <disk_unlock>
4000349c: b0 10 00 10 mov %l0, %i0
400034a0: 30 bf ff f6 b,a 40003478 <rtems_disk_create_phys+0x8c>
40003128 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
40003128: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
4000312c: 7f ff ff 71 call 40002ef0 <disk_lock>
40003130: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40003134: a0 92 20 00 orcc %o0, 0, %l0
40003138: 02 80 00 04 be 40003148 <rtems_disk_delete+0x20> <== ALWAYS TAKEN
4000313c: 90 10 00 18 mov %i0, %o0
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
40003140: 81 c7 e0 08 ret <== NOT EXECUTED
40003144: 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);
40003148: 92 10 00 19 mov %i1, %o1
4000314c: 7f ff ff 2c call 40002dfc <get_disk_entry>
40003150: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
40003154: 82 92 20 00 orcc %o0, 0, %g1
40003158: 02 80 00 5e be 400032d0 <rtems_disk_delete+0x1a8> <== NEVER TAKEN
4000315c: 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;
40003160: e2 00 60 08 ld [ %g1 + 8 ], %l1
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
40003164: 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) {
40003168: c4 0c 60 40 ldub [ %l1 + 0x40 ], %g2
4000316c: 80 a0 a0 00 cmp %g2, 0
40003170: 22 80 00 43 be,a 4000327c <rtems_disk_delete+0x154>
40003174: 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) {
40003178: 2b 10 00 6b sethi %hi(0x4001ac00), %l5
4000317c: c2 05 62 18 ld [ %l5 + 0x218 ], %g1 ! 4001ae18 <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;
40003180: f2 04 40 00 ld [ %l1 ], %i1
40003184: e4 04 60 04 ld [ %l1 + 4 ], %l2
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
40003188: 80 a0 60 00 cmp %g1, 0
4000318c: 02 80 00 33 be 40003258 <rtems_disk_delete+0x130> <== NEVER TAKEN
40003190: a8 10 20 00 clr %l4
40003194: 2d 10 00 6b sethi %hi(0x4001ac00), %l6
40003198: b0 10 20 00 clr %i0
4000319c: ac 15 a2 1c or %l6, 0x21c, %l6
400031a0: aa 15 62 18 or %l5, 0x218, %l5
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
400031a4: 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;
400031a8: f6 05 80 00 ld [ %l6 ], %i3
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400031ac: 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;
400031b0: b6 06 c0 01 add %i3, %g1, %i3
for (minor = 0; minor < dtab->size; ++minor) {
400031b4: f4 06 e0 04 ld [ %i3 + 4 ], %i2
400031b8: 80 a6 a0 00 cmp %i2, 0
400031bc: 22 80 00 23 be,a 40003248 <rtems_disk_delete+0x120>
400031c0: c2 05 40 00 ld [ %l5 ], %g1
400031c4: 10 80 00 06 b 400031dc <rtems_disk_delete+0xb4>
400031c8: ba 10 20 00 clr %i5
400031cc: ba 07 60 01 inc %i5
400031d0: 80 a7 40 1a cmp %i5, %i2
400031d4: 3a 80 00 1d bcc,a 40003248 <rtems_disk_delete+0x120>
400031d8: c2 05 40 00 ld [ %l5 ], %g1
rtems_disk_device *dd = dtab->minor [minor];
400031dc: c6 06 c0 00 ld [ %i3 ], %g3
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400031e0: 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];
400031e4: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
400031e8: 80 a2 20 00 cmp %o0, 0
400031ec: 22 bf ff f9 be,a 400031d0 <rtems_disk_delete+0xa8>
400031f0: ba 07 60 01 inc %i5
400031f4: c8 02 20 08 ld [ %o0 + 8 ], %g4
400031f8: f8 01 00 00 ld [ %g4 ], %i4
400031fc: 80 a7 00 19 cmp %i4, %i1
40003200: 32 bf ff f4 bne,a 400031d0 <rtems_disk_delete+0xa8> <== NEVER TAKEN
40003204: ba 07 60 01 inc %i5 <== NOT EXECUTED
40003208: c8 01 20 04 ld [ %g4 + 4 ], %g4
4000320c: 80 a1 00 12 cmp %g4, %l2
40003210: 32 bf ff f0 bne,a 400031d0 <rtems_disk_delete+0xa8> <== NEVER TAKEN
40003214: ba 07 60 01 inc %i5 <== NOT EXECUTED
40003218: 80 a4 40 08 cmp %l1, %o0
4000321c: 22 bf ff ed be,a 400031d0 <rtems_disk_delete+0xa8>
40003220: ba 07 60 01 inc %i5
if (dd->uses == 0) {
40003224: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
40003228: 80 a1 20 00 cmp %g4, 0
4000322c: 22 80 00 25 be,a 400032c0 <rtems_disk_delete+0x198>
40003230: 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) {
40003234: ba 07 60 01 inc %i5
40003238: 80 a7 40 1a cmp %i5, %i2
4000323c: 0a bf ff e8 bcs 400031dc <rtems_disk_delete+0xb4> <== ALWAYS TAKEN
40003240: 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) {
40003244: c2 05 40 00 ld [ %l5 ], %g1 <== NOT EXECUTED
40003248: b0 06 20 01 inc %i0
4000324c: 80 a6 00 01 cmp %i0, %g1
40003250: 2a bf ff d7 bcs,a 400031ac <rtems_disk_delete+0x84>
40003254: f6 05 80 00 ld [ %l6 ], %i3
}
}
}
}
physical_disk->uses -= deleted_count;
40003258: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
4000325c: a8 20 40 14 sub %g1, %l4, %l4
if (physical_disk->uses == 0) {
40003260: 80 a5 20 00 cmp %l4, 0
40003264: 02 80 00 1f be 400032e0 <rtems_disk_delete+0x1b8>
40003268: e8 24 60 14 st %l4, [ %l1 + 0x14 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
4000326c: 7f ff ff 30 call 40002f2c <disk_unlock>
40003270: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
40003274: 81 c7 e0 08 ret
40003278: 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) {
4000327c: 80 a0 a0 00 cmp %g2, 0
40003280: 12 bf ff fb bne 4000326c <rtems_disk_delete+0x144> <== NEVER TAKEN
40003284: 07 10 00 6b sethi %hi(0x4001ac00), %g3
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
40003288: c4 00 40 00 ld [ %g1 ], %g2
disktab [major].minor [minor] = NULL;
4000328c: c8 00 e2 1c ld [ %g3 + 0x21c ], %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);
40003290: 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;
40003294: c6 04 60 14 ld [ %l1 + 0x14 ], %g3
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
40003298: 85 28 a0 03 sll %g2, 3, %g2
4000329c: 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;
400032a0: 86 00 ff ff add %g3, -1, %g3
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
400032a4: 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;
400032a8: 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);
400032ac: 7f ff fe fb call 40002e98 <free_disk_device>
400032b0: c0 20 80 01 clr [ %g2 + %g1 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
400032b4: 7f ff ff 1e call 40002f2c <disk_unlock>
400032b8: b0 10 00 10 mov %l0, %i0
400032bc: 30 bf ff ee b,a 40003274 <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);
400032c0: 7f ff fe f6 call 40002e98 <free_disk_device>
400032c4: a8 05 20 01 inc %l4
400032c8: 10 bf ff c1 b 400031cc <rtems_disk_delete+0xa4>
400032cc: f4 06 e0 04 ld [ %i3 + 4 ], %i2
return sc;
}
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
400032d0: 7f ff ff 17 call 40002f2c <disk_unlock> <== NOT EXECUTED
400032d4: a0 10 20 04 mov 4, %l0 <== NOT EXECUTED
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
400032d8: 81 c7 e0 08 ret <== NOT EXECUTED
400032dc: 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);
400032e0: c4 04 40 00 ld [ %l1 ], %g2
disktab [major].minor [minor] = NULL;
400032e4: 03 10 00 6b sethi %hi(0x4001ac00), %g1
400032e8: c6 00 62 1c ld [ %g1 + 0x21c ], %g3 ! 4001ae1c <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
400032ec: c2 04 60 04 ld [ %l1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
400032f0: 85 28 a0 03 sll %g2, 3, %g2
400032f4: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
400032f8: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
400032fc: 90 10 00 11 mov %l1, %o0
40003300: 7f ff fe e6 call 40002e98 <free_disk_device>
40003304: c0 20 80 01 clr [ %g2 + %g1 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
40003308: 7f ff ff 09 call 40002f2c <disk_unlock>
4000330c: b0 10 00 10 mov %l0, %i0
40003310: 30 bf ff d9 b,a 40003274 <rtems_disk_delete+0x14c>
40003718 <rtems_disk_io_done>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
40003718: 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) {
4000371c: 21 10 00 6b sethi %hi(0x4001ac00), %l0
40003720: c2 04 22 18 ld [ %l0 + 0x218 ], %g1 ! 4001ae18 <disktab_size>
40003724: 35 10 00 6b sethi %hi(0x4001ac00), %i2
40003728: b6 10 20 00 clr %i3
4000372c: fa 06 a2 1c ld [ %i2 + 0x21c ], %i5
40003730: 80 a0 60 00 cmp %g1, 0
40003734: 02 80 00 1d be 400037a8 <rtems_disk_io_done+0x90> <== NEVER TAKEN
40003738: b2 14 22 18 or %l0, 0x218, %i1
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
4000373c: 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;
40003740: b8 07 40 01 add %i5, %g1, %i4
for (minor = 0; minor < dtab->size; ++minor) {
40003744: c4 07 20 04 ld [ %i4 + 4 ], %g2
40003748: 80 a0 a0 00 cmp %g2, 0
4000374c: 02 80 00 10 be 4000378c <rtems_disk_io_done+0x74>
40003750: c6 07 40 01 ld [ %i5 + %g1 ], %g3
40003754: ba 10 20 00 clr %i5
rtems_disk_device *dd = dtab->minor [minor];
40003758: 83 2f 60 02 sll %i5, 2, %g1
4000375c: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
if (dd != NULL) {
40003760: 90 90 60 00 orcc %g1, 0, %o0
40003764: 02 80 00 06 be 4000377c <rtems_disk_io_done+0x64>
40003768: ba 07 60 01 inc %i5
free_disk_device(dd);
4000376c: 7f ff fd cb call 40002e98 <free_disk_device>
40003770: 01 00 00 00 nop
40003774: c4 07 20 04 ld [ %i4 + 4 ], %g2
40003778: 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) {
4000377c: 80 a0 80 1d cmp %g2, %i5
40003780: 18 bf ff f7 bgu 4000375c <rtems_disk_io_done+0x44>
40003784: 83 2f 60 02 sll %i5, 2, %g1
40003788: fa 06 a2 1c ld [ %i2 + 0x21c ], %i5
if (dd != NULL) {
free_disk_device(dd);
}
}
free(dtab->minor);
4000378c: 40 00 02 31 call 40004050 <free>
40003790: 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) {
40003794: c2 06 40 00 ld [ %i1 ], %g1
40003798: b6 06 e0 01 inc %i3
4000379c: 80 a0 40 1b cmp %g1, %i3
400037a0: 18 bf ff e8 bgu 40003740 <rtems_disk_io_done+0x28>
400037a4: 83 2e e0 03 sll %i3, 3, %g1
free_disk_device(dd);
}
}
free(dtab->minor);
}
free(disktab);
400037a8: 40 00 02 2a call 40004050 <free>
400037ac: 90 10 00 1d mov %i5, %o0
rtems_semaphore_delete(diskdevs_mutex);
400037b0: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
400037b4: d0 07 62 14 ld [ %i5 + 0x214 ], %o0 ! 4001ae14 <diskdevs_mutex>
400037b8: 40 00 13 6d call 4000856c <rtems_semaphore_delete>
400037bc: b0 10 20 00 clr %i0
diskdevs_mutex = RTEMS_ID_NONE;
400037c0: c0 27 62 14 clr [ %i5 + 0x214 ]
disktab = NULL;
400037c4: c0 26 a2 1c clr [ %i2 + 0x21c ]
disktab_size = 0;
400037c8: c0 24 22 18 clr [ %l0 + 0x218 ]
return RTEMS_SUCCESSFUL;
}
400037cc: 81 c7 e0 08 ret
400037d0: 81 e8 00 00 restore
4000366c <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
4000366c: 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) {
40003670: 3b 10 00 6b sethi %hi(0x4001ac00), %i5
40003674: c2 07 62 18 ld [ %i5 + 0x218 ], %g1 ! 4001ae18 <disktab_size>
40003678: 80 a0 60 00 cmp %g1, 0
4000367c: 12 80 00 19 bne 400036e0 <rtems_disk_io_initialize+0x74>
40003680: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
40003684: 90 10 20 08 mov 8, %o0
40003688: 92 10 20 08 mov 8, %o1
4000368c: 40 00 02 3a call 40003f74 <calloc>
40003690: 39 10 00 6b sethi %hi(0x4001ac00), %i4
40003694: d0 27 22 1c st %o0, [ %i4 + 0x21c ] ! 4001ae1c <disktab>
if (disktab == NULL) {
40003698: 80 a2 20 00 cmp %o0, 0
4000369c: 02 80 00 11 be 400036e0 <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
400036a0: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
400036a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1
sc = rtems_semaphore_create(
400036a8: 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;
400036ac: c0 28 62 10 clrb [ %g1 + 0x210 ]
sc = rtems_semaphore_create(
400036b0: 90 12 21 56 or %o0, 0x156, %o0
400036b4: 92 10 20 01 mov 1, %o1
400036b8: 94 10 20 10 mov 0x10, %o2
400036bc: 96 10 20 00 clr %o3
400036c0: 37 10 00 6b sethi %hi(0x4001ac00), %i3
400036c4: 40 00 13 39 call 400083a8 <rtems_semaphore_create>
400036c8: 98 16 e2 14 or %i3, 0x214, %o4 ! 4001ae14 <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
400036cc: 80 a2 20 00 cmp %o0, 0
400036d0: 02 80 00 06 be 400036e8 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
400036d4: 01 00 00 00 nop
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
free(disktab);
400036d8: 40 00 02 5e call 40004050 <free> <== NOT EXECUTED
400036dc: d0 07 22 1c ld [ %i4 + 0x21c ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
400036e0: 81 c7 e0 08 ret
400036e4: 81 e8 00 00 restore
free(disktab);
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
400036e8: 40 00 2b 0a call 4000e310 <rtems_bdbuf_init>
400036ec: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400036f0: 80 a2 20 00 cmp %o0, 0
400036f4: 12 80 00 05 bne 40003708 <rtems_disk_io_initialize+0x9c> <== NEVER TAKEN
400036f8: 82 10 20 08 mov 8, %g1
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
400036fc: c2 27 62 18 st %g1, [ %i5 + 0x218 ]
return RTEMS_SUCCESSFUL;
}
40003700: 81 c7 e0 08 ret
40003704: 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);
40003708: d0 06 e2 14 ld [ %i3 + 0x214 ], %o0 <== NOT EXECUTED
4000370c: 40 00 13 98 call 4000856c <rtems_semaphore_delete> <== NOT EXECUTED
40003710: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
40003714: 30 bf ff f1 b,a 400036d8 <rtems_disk_io_initialize+0x6c> <== NOT EXECUTED
40003574 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
40003574: 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) {
40003578: 80 a6 3f ff cmp %i0, -1
4000357c: 02 80 00 37 be 40003658 <rtems_disk_next+0xe4>
40003580: 80 a6 7f ff cmp %i1, -1
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
40003584: ba 06 60 01 add %i1, 1, %i5
40003588: 80 a7 40 19 cmp %i5, %i1
4000358c: 0a 80 00 2e bcs 40003644 <rtems_disk_next+0xd0> <== NEVER TAKEN
40003590: b8 10 00 18 mov %i0, %i4
} else {
++minor;
}
}
sc = disk_lock();
40003594: 7f ff fe 57 call 40002ef0 <disk_lock>
40003598: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
4000359c: 80 a2 20 00 cmp %o0, 0
400035a0: 12 80 00 27 bne 4000363c <rtems_disk_next+0xc8> <== NEVER TAKEN
400035a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1
return NULL;
}
if (major >= disktab_size) {
400035a8: c8 00 62 18 ld [ %g1 + 0x218 ], %g4 ! 4001ae18 <disktab_size>
400035ac: 80 a7 00 04 cmp %i4, %g4
400035b0: 1a 80 00 21 bcc 40003634 <rtems_disk_next+0xc0> <== NEVER TAKEN
400035b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1
disk_unlock();
return NULL;
}
dtab = disktab + major;
400035b8: c6 00 62 1c ld [ %g1 + 0x21c ], %g3 ! 4001ae1c <disktab>
400035bc: b7 2f 20 03 sll %i4, 3, %i3
400035c0: c2 00 c0 1b ld [ %g3 + %i3 ], %g1
400035c4: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
400035c8: 80 a0 60 00 cmp %g1, 0
400035cc: 02 80 00 12 be 40003614 <rtems_disk_next+0xa0>
400035d0: b5 2f 60 02 sll %i5, 2, %i2
400035d4: c4 06 e0 04 ld [ %i3 + 4 ], %g2
400035d8: 80 a7 40 02 cmp %i5, %g2
400035dc: 3a 80 00 0f bcc,a 40003618 <rtems_disk_next+0xa4>
400035e0: b8 07 20 01 inc %i4
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
400035e4: c4 00 40 1a ld [ %g1 + %i2 ], %g2
400035e8: 80 a0 a0 00 cmp %g2, 0
400035ec: 02 bf ff f7 be 400035c8 <rtems_disk_next+0x54>
400035f0: ba 07 60 01 inc %i5
++minor;
} else {
++dtab->minor [minor]->uses;
400035f4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400035f8: 82 00 60 01 inc %g1
disk_unlock();
400035fc: 7f ff fe 4c call 40002f2c <disk_unlock>
40003600: c2 20 a0 14 st %g1, [ %g2 + 0x14 ]
return dtab->minor [minor];
40003604: c2 06 c0 00 ld [ %i3 ], %g1
40003608: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
4000360c: 81 c7 e0 08 ret
40003610: 81 e8 00 00 restore
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
40003614: b8 07 20 01 inc %i4
if (major >= disktab_size) {
40003618: 80 a1 00 1c cmp %g4, %i4
4000361c: 08 80 00 06 bleu 40003634 <rtems_disk_next+0xc0>
40003620: 83 2f 20 03 sll %i4, 3, %g1
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
40003624: ba 10 20 00 clr %i5
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
40003628: b6 00 c0 01 add %g3, %g1, %i3
4000362c: 10 bf ff e7 b 400035c8 <rtems_disk_next+0x54>
40003630: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
disk_unlock();
40003634: 7f ff fe 3e call 40002f2c <disk_unlock>
40003638: 01 00 00 00 nop
return NULL;
4000363c: 81 c7 e0 08 ret
40003640: 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) {
40003644: b8 06 20 01 add %i0, 1, %i4 <== NOT EXECUTED
40003648: 80 a7 00 18 cmp %i4, %i0 <== NOT EXECUTED
4000364c: 1a bf ff d2 bcc 40003594 <rtems_disk_next+0x20> <== NOT EXECUTED
40003650: ba 10 20 00 clr %i5 <== NOT EXECUTED
40003654: 30 bf ff fa b,a 4000363c <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) {
40003658: 32 bf ff cc bne,a 40003588 <rtems_disk_next+0x14> <== NEVER TAKEN
4000365c: 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;
40003660: 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;
40003664: 10 bf ff cc b 40003594 <rtems_disk_next+0x20>
40003668: b8 10 20 00 clr %i4
400034a4 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
400034a4: 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);
400034a8: 7f ff fc e9 call 4000284c <sparc_disable_interrupts>
400034ac: b8 10 00 18 mov %i0, %i4
400034b0: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
400034b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1
400034b8: c2 08 62 10 ldub [ %g1 + 0x210 ], %g1 ! 4001ae10 <diskdevs_protected>
400034bc: 80 a0 60 00 cmp %g1, 0
400034c0: 22 80 00 10 be,a 40003500 <rtems_disk_obtain+0x5c> <== ALWAYS TAKEN
400034c4: 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);
400034c8: 7f ff fc e5 call 4000285c <sparc_enable_interrupts> <== NOT EXECUTED
400034cc: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
400034d0: 7f ff fe 88 call 40002ef0 <disk_lock> <== NOT EXECUTED
400034d4: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
400034d8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400034dc: 12 80 00 07 bne 400034f8 <rtems_disk_obtain+0x54> <== NOT EXECUTED
400034e0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
400034e4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400034e8: 7f ff fe 45 call 40002dfc <get_disk_entry> <== NOT EXECUTED
400034ec: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
400034f0: 7f ff fe 8f call 40002f2c <disk_unlock> <== NOT EXECUTED
400034f4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
400034f8: 81 c7 e0 08 ret <== NOT EXECUTED
400034fc: 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);
40003500: 92 10 00 19 mov %i1, %o1
40003504: 7f ff fe 3e call 40002dfc <get_disk_entry>
40003508: 94 10 20 00 clr %o2
4000350c: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
40003510: 7f ff fc d3 call 4000285c <sparc_enable_interrupts>
40003514: 90 10 00 1b mov %i3, %o0
40003518: 81 c7 e0 08 ret
4000351c: 81 e8 00 00 restore
400112b0 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
400112b0: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
400112b4: 80 a6 e0 00 cmp %i3, 0
400112b8: 02 80 00 0a be 400112e0 <rtems_event_system_receive+0x30> <== NEVER TAKEN
400112bc: 82 10 20 09 mov 9, %g1
Thread_Control *executing = _Thread_Executing;
400112c0: 03 10 00 6d sethi %hi(0x4001b400), %g1
400112c4: fa 00 63 f0 ld [ %g1 + 0x3f0 ], %i5 ! 4001b7f0 <_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 ) ) {
400112c8: 80 a6 20 00 cmp %i0, 0
400112cc: 12 80 00 07 bne 400112e8 <rtems_event_system_receive+0x38><== ALWAYS TAKEN
400112d0: da 07 61 4c ld [ %i5 + 0x14c ], %o5
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
400112d4: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
400112d8: 82 10 20 00 clr %g1 <== NOT EXECUTED
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
400112dc: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
400112e0: 81 c7 e0 08 ret <== NOT EXECUTED
400112e4: 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;
400112e8: 03 10 00 6c sethi %hi(0x4001b000), %g1
400112ec: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 4001b2d0 <_Thread_Dispatch_disable_level>
++level;
400112f0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400112f4: c4 20 62 d0 st %g2, [ %g1 + 0x2d0 ]
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(
400112f8: 03 00 01 00 sethi %hi(0x40000), %g1
400112fc: 90 10 00 18 mov %i0, %o0
40011300: 92 10 00 19 mov %i1, %o1
40011304: 94 10 00 1a mov %i2, %o2
40011308: 96 10 00 1b mov %i3, %o3
4001130c: 98 10 00 1d mov %i5, %o4
40011310: 9a 03 60 04 add %o5, 4, %o5
40011314: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40011318: 03 10 00 6e sethi %hi(0x4001b800), %g1
4001131c: 82 10 63 e0 or %g1, 0x3e0, %g1 ! 4001bbe0 <_System_event_Sync_state>
40011320: 7f ff db 4f call 4000805c <_Event_Seize>
40011324: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
40011328: 7f ff e7 5e call 4000b0a0 <_Thread_Enable_dispatch>
4001132c: 01 00 00 00 nop
sc = executing->Wait.return_code;
40011330: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
40011334: 81 c7 e0 08 ret
40011338: 91 e8 00 01 restore %g0, %g1, %o0
40007574 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
40007574: 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 );
40007578: 90 10 00 18 mov %i0, %o0
4000757c: 40 00 0a 5f call 40009ef8 <_Thread_Get>
40007580: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40007584: c2 07 bf fc ld [ %fp + -4 ], %g1
40007588: 80 a0 60 00 cmp %g1, 0
4000758c: 12 80 00 0d bne 400075c0 <rtems_event_system_send+0x4c> <== NEVER TAKEN
40007590: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
40007594: d4 02 21 4c ld [ %o0 + 0x14c ], %o2
40007598: 94 02 a0 04 add %o2, 4, %o2
4000759c: 19 00 01 00 sethi %hi(0x40000), %o4
400075a0: 17 10 00 7d sethi %hi(0x4001f400), %o3
400075a4: 96 12 e3 d0 or %o3, 0x3d0, %o3 ! 4001f7d0 <_System_event_Sync_state>
400075a8: 7f ff fe 54 call 40006ef8 <_Event_Surrender>
400075ac: b0 10 20 00 clr %i0
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
400075b0: 40 00 0a 46 call 40009ec8 <_Thread_Enable_dispatch>
400075b4: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
break;
400075b8: 81 c7 e0 08 ret
400075bc: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
400075c0: 81 c7 e0 08 ret <== NOT EXECUTED
400075c4: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
400075a0 <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, ...)
400075a0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:abort:");
400075a4: 31 10 00 e4 sethi %hi(0x40039000), %i0 <== NOT EXECUTED
400075a8: c2 06 23 70 ld [ %i0 + 0x370 ], %g1 ! 40039370 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
400075ac: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
400075b0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
400075b4: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
400075b8: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
400075bc: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
400075c0: 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);
400075c4: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
400075c8: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
400075cc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
400075d0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
400075d4: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400075d8: 40 00 70 d4 call 40023928 <fwrite> <== NOT EXECUTED
400075dc: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 400346d0 <__FUNCTION__.6193+0x608><== NOT EXECUTED
vfprintf (stderr, format, args);
400075e0: c2 06 23 70 ld [ %i0 + 0x370 ], %g1 <== NOT EXECUTED
400075e4: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400075e8: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
400075ec: 40 00 6f 22 call 40023274 <fputs> <== NOT EXECUTED
400075f0: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
400075f4: c2 06 23 70 ld [ %i0 + 0x370 ], %g1 <== NOT EXECUTED
400075f8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
400075fc: 40 00 6e ea call 400231a4 <fputc> <== NOT EXECUTED
40007600: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
40007604: c2 06 23 70 ld [ %i0 + 0x370 ], %g1 <== NOT EXECUTED
40007608: 40 00 6d cf call 40022d44 <fflush> <== NOT EXECUTED
4000760c: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
40007610: 40 00 6c cd call 40022944 <exit> <== NOT EXECUTED
40007614: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
400055a8 <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)
{
400055a8: 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)
400055ac: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
400055b0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400055b4: 80 a0 80 01 cmp %g2, %g1
400055b8: 1a 80 00 20 bcc 40005638 <rtems_fdisk_compact+0x90>
400055bc: a6 10 00 18 mov %i0, %l3
fd->starvations++;
400055c0: 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");
400055c4: 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++;
400055c8: 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");
400055cc: 13 10 00 d1 sethi %hi(0x40034400), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
400055d0: 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");
400055d4: 7f ff fc a7 call 40004870 <rtems_fdisk_printf>
400055d8: 92 12 61 d8 or %o1, 0x1d8, %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)
400055dc: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
400055e0: 80 a7 60 00 cmp %i5, 0
400055e4: 22 80 00 83 be,a 400057f0 <rtems_fdisk_compact+0x248> <== NEVER TAKEN
400055e8: fa 06 20 34 ld [ %i0 + 0x34 ], %i5 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400055ec: c2 07 40 00 ld [ %i5 ], %g1
if (!queue->head)
400055f0: 80 a0 60 00 cmp %g1, 0
400055f4: 02 80 00 9f be 40005870 <rtems_fdisk_compact+0x2c8> <== NEVER TAKEN
400055f8: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
queue->tail = 0;
queue->count--;
400055fc: c2 04 e0 48 ld [ %l3 + 0x48 ], %g1
40005600: 82 00 7f ff add %g1, -1, %g1
40005604: c2 24 e0 48 st %g1, [ %l3 + 0x48 ]
sc->next = 0;
40005608: 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);
4000560c: 7f ff fc 59 call 40004770 <rtems_fdisk_seg_most_available>
40005610: 90 04 e0 34 add %l3, 0x34, %o0
if (dsc)
40005614: 94 92 20 00 orcc %o0, 0, %o2
40005618: 02 80 00 8b be 40005844 <rtems_fdisk_compact+0x29c> <== NEVER TAKEN
4000561c: 92 10 00 1d mov %i5, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
40005620: 90 10 00 13 mov %l3, %o0
40005624: 7f ff fe d1 call 40005168 <rtems_fdisk_recycle_segment>
40005628: 96 07 bf fc add %fp, -4, %o3
if (ret)
4000562c: b0 92 20 00 orcc %o0, 0, %i0
40005630: 12 80 00 8e bne 40005868 <rtems_fdisk_compact+0x2c0> <== NEVER TAKEN
40005634: 01 00 00 00 nop
40005638: d2 04 e0 40 ld [ %l3 + 0x40 ], %o1
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4000563c: 21 10 00 d1 sethi %hi(0x40034400), %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",
40005640: 23 10 00 d1 sethi %hi(0x40034400), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40005644: 25 10 00 d1 sethi %hi(0x40034400), %l2
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
40005648: b8 10 20 00 clr %i4
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4000564c: a0 14 22 08 or %l0, 0x208, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
40005650: 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",
40005654: a2 14 62 50 or %l1, 0x250, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40005658: a4 14 a2 88 or %l2, 0x288, %l2
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
4000565c: 80 a2 60 00 cmp %o1, 0
40005660: 02 80 00 70 be 40005820 <rtems_fdisk_compact+0x278>
40005664: 92 10 00 10 mov %l0, %o1
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
40005668: 7f ff fc 82 call 40004870 <rtems_fdisk_printf>
4000566c: 90 10 00 13 mov %l3, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
40005670: 7f ff fc 40 call 40004770 <rtems_fdisk_seg_most_available>
40005674: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
40005678: b4 92 20 00 orcc %o0, 0, %i2
4000567c: 02 80 00 6b be 40005828 <rtems_fdisk_compact+0x280> <== NEVER TAKEN
40005680: 11 10 00 d1 sethi %hi(0x40034400), %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)
40005684: f6 06 a0 24 ld [ %i2 + 0x24 ], %i3
40005688: 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);
4000568c: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
40005690: 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",
40005694: d4 06 a0 08 ld [ %i2 + 8 ], %o2
40005698: d6 06 a0 0c ld [ %i2 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
4000569c: 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)
400056a0: b6 06 c0 03 add %i3, %g3, %i3
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
400056a4: 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);
400056a8: 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",
400056ac: 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);
400056b0: 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",
400056b4: 7f ff fc 6f call 40004870 <rtems_fdisk_printf>
400056b8: 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 &&
400056bc: 80 a7 60 00 cmp %i5, 0
400056c0: 02 80 00 1b be 4000572c <rtems_fdisk_compact+0x184> <== NEVER TAKEN
400056c4: c2 07 bf fc ld [ %fp + -4 ], %g1
((pages + ssc->pages_active) < dst_pages) &&
400056c8: d8 07 60 1c ld [ %i5 + 0x1c ], %o4
400056cc: 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 &&
400056d0: 80 a6 c0 0c cmp %i3, %o4
400056d4: 28 80 00 45 bleu,a 400057e8 <rtems_fdisk_compact+0x240>
400056d8: 98 10 00 01 mov %g1, %o4
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
400056dc: 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) &&
400056e0: 80 a7 00 03 cmp %i4, %g3
400056e4: 3a 80 00 41 bcc,a 400057e8 <rtems_fdisk_compact+0x240> <== NEVER TAKEN
400056e8: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED
400056ec: 10 80 00 0b b 40005718 <rtems_fdisk_compact+0x170>
400056f0: 9a 10 20 00 clr %o5
400056f4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400056f8: 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 &&
400056fc: 80 a0 40 1b cmp %g1, %i3
40005700: 1a 80 00 12 bcc 40005748 <rtems_fdisk_compact+0x1a0>
40005704: 84 07 00 0d add %i4, %o5, %g2
((pages + ssc->pages_active) < dst_pages) &&
40005708: 80 a0 80 03 cmp %g2, %g3
4000570c: 3a 80 00 10 bcc,a 4000574c <rtems_fdisk_compact+0x1a4> <== NEVER TAKEN
40005710: d8 27 bf fc st %o4, [ %fp + -4 ] <== NOT EXECUTED
40005714: 98 10 00 01 mov %g1, %o4
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
ssc = ssc->next;
40005718: 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 &&
4000571c: 80 a7 60 00 cmp %i5, 0
40005720: 12 bf ff f5 bne 400056f4 <rtems_fdisk_compact+0x14c>
40005724: 9a 03 60 01 inc %o5
40005728: 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");
4000572c: 90 10 00 13 mov %l3, %o0
40005730: 13 10 00 d1 sethi %hi(0x40034400), %o1
}
compacted_segs += segments;
}
return 0;
40005734: 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");
40005738: 7f ff fc 4e call 40004870 <rtems_fdisk_printf>
4000573c: 92 12 62 70 or %o1, 0x270, %o1
#endif
break;
40005740: 81 c7 e0 08 ret
40005744: 81 e8 00 00 restore
40005748: 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))
4000574c: 80 a3 20 00 cmp %o4, 0
40005750: 02 bf ff f8 be 40005730 <rtems_fdisk_compact+0x188>
40005754: 90 10 00 13 mov %l3, %o0
40005758: b8 07 00 0d add %i4, %o5, %i4
4000575c: 80 a7 20 01 cmp %i4, 1
40005760: 22 bf ff f5 be,a 40005734 <rtems_fdisk_compact+0x18c>
40005764: 13 10 00 d1 sethi %hi(0x40034400), %o1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40005768: d4 07 60 08 ld [ %i5 + 8 ], %o2
4000576c: d6 07 60 0c ld [ %i5 + 0xc ], %o3
40005770: 92 10 00 12 mov %l2, %o1
40005774: 7f ff fc 3f call 40004870 <rtems_fdisk_printf>
40005778: 90 10 00 13 mov %l3, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
4000577c: 90 10 00 19 mov %i1, %o0
40005780: 7f ff fb 9b call 400045ec <rtems_fdisk_segment_queue_remove>
40005784: 92 10 00 1a mov %i2, %o1
40005788: c2 07 bf fc ld [ %fp + -4 ], %g1
4000578c: d2 04 e0 40 ld [ %l3 + 0x40 ], %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
40005790: 80 a0 60 00 cmp %g1, 0
40005794: 02 bf ff b3 be 40005660 <rtems_fdisk_compact+0xb8>
40005798: 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)
4000579c: 02 bf ff fe be 40005794 <rtems_fdisk_compact+0x1ec> <== NEVER TAKEN
400057a0: 80 a0 60 00 cmp %g1, 0
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400057a4: c2 02 40 00 ld [ %o1 ], %g1
if (!queue->head)
400057a8: 80 a0 60 00 cmp %g1, 0
400057ac: 02 80 00 24 be 4000583c <rtems_fdisk_compact+0x294> <== NEVER TAKEN
400057b0: c2 24 e0 40 st %g1, [ %l3 + 0x40 ]
queue->tail = 0;
queue->count--;
400057b4: 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);
400057b8: 90 10 00 13 mov %l3, %o0
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
queue->count--;
400057bc: 82 00 7f ff add %g1, -1, %g1
400057c0: c2 24 e0 48 st %g1, [ %l3 + 0x48 ]
sc->next = 0;
400057c4: 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);
400057c8: 94 10 00 1a mov %i2, %o2
400057cc: 7f ff fe 67 call 40005168 <rtems_fdisk_recycle_segment>
400057d0: 96 07 bf fc add %fp, -4, %o3
if (ret)
400057d4: b0 92 20 00 orcc %o0, 0, %i0
400057d8: 02 bf ff ed be 4000578c <rtems_fdisk_compact+0x1e4> <== ALWAYS TAKEN
400057dc: c2 07 bf fc ld [ %fp + -4 ], %g1
compacted_segs += segments;
}
return 0;
}
400057e0: 81 c7 e0 08 ret <== NOT EXECUTED
400057e4: 81 e8 00 00 restore <== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
400057e8: 10 bf ff d9 b 4000574c <rtems_fdisk_compact+0x1a4>
400057ec: 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)
400057f0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400057f4: 02 80 00 1a be 4000585c <rtems_fdisk_compact+0x2b4> <== NOT EXECUTED
400057f8: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400057fc: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
if (!queue->head)
40005800: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005804: 02 80 00 1d be 40005878 <rtems_fdisk_compact+0x2d0> <== NOT EXECUTED
40005808: c2 24 e0 34 st %g1, [ %l3 + 0x34 ] <== NOT EXECUTED
queue->tail = 0;
queue->count--;
4000580c: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED
40005810: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40005814: c2 24 e0 3c st %g1, [ %l3 + 0x3c ] <== NOT EXECUTED
sc->next = 0;
40005818: 10 bf ff 7d b 4000560c <rtems_fdisk_compact+0x64> <== NOT EXECUTED
4000581c: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
}
compacted_segs += segments;
}
return 0;
40005820: 81 c7 e0 08 ret
40005824: 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;
40005828: 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");
4000582c: 7f ff fc eb call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005830: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
40005834: 81 c7 e0 08 ret <== NOT EXECUTED
40005838: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
4000583c: 10 bf ff de b 400057b4 <rtems_fdisk_compact+0x20c> <== NOT EXECUTED
40005840: c0 24 e0 44 clr [ %l3 + 0x44 ] <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
40005844: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
return EIO;
40005848: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
4000584c: 7f ff fc e3 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005850: 90 12 21 f0 or %o0, 0x1f0, %o0 <== NOT EXECUTED
40005854: 81 c7 e0 08 ret <== NOT EXECUTED
40005858: 81 e8 00 00 restore <== NOT EXECUTED
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
4000585c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
40005860: 7f ff fc de call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005864: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
40005868: 81 c7 e0 08 ret <== NOT EXECUTED
4000586c: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
40005870: 10 bf ff 63 b 400055fc <rtems_fdisk_compact+0x54> <== NOT EXECUTED
40005874: c0 26 20 44 clr [ %i0 + 0x44 ] <== NOT EXECUTED
40005878: 10 bf ff e5 b 4000580c <rtems_fdisk_compact+0x264> <== NOT EXECUTED
4000587c: c0 24 e0 38 clr [ %l3 + 0x38 ] <== NOT EXECUTED
40004c54 <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
40004c54: 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;
40004c58: 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;
40004c5c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40004c60: 87 2a 60 04 sll %o1, 4, %g3
40004c64: 83 2a 60 02 sll %o1, 2, %g1
40004c68: 82 20 c0 01 sub %g3, %g1, %g1
40004c6c: 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;
40004c70: 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;
40004c74: 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);
40004c78: 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;
40004c7c: c6 00 80 01 ld [ %g2 + %g1 ], %g3
40004c80: 89 2a a0 06 sll %o2, 6, %g4
40004c84: 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);
40004c88: 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;
40004c8c: 84 21 00 02 sub %g4, %g2, %g2
40004c90: 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);
40004c94: d0 00 a0 04 ld [ %g2 + 4 ], %o0
40004c98: 9f c0 40 00 call %g1
40004c9c: ba 10 00 18 mov %i0, %i5
if (ret)
40004ca0: b0 92 20 00 orcc %o0, 0, %i0
40004ca4: 22 80 00 24 be,a 40004d34 <rtems_fdisk_erase_segment+0xe0><== ALWAYS TAKEN
40004ca8: c6 07 60 28 ld [ %i5 + 0x28 ], %g3
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
40004cac: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
40004cb0: 40 00 80 fd call 400250a4 <strerror> <== NOT EXECUTED
40004cb4: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
40004cb8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40004cbc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40004cc0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40004cc4: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40004cc8: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40004ccc: 7f ff ff c3 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40004cd0: 90 12 23 c0 or %o0, 0x3c0, %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;
40004cd4: 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;
40004cd8: 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)
40004cdc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004ce0: 02 80 00 36 be 40004db8 <rtems_fdisk_erase_segment+0x164> <== NOT EXECUTED
40004ce4: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
{
if (it == sc)
40004ce8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
40004cec: 32 80 00 06 bne,a 40004d04 <rtems_fdisk_erase_segment+0xb0><== NOT EXECUTED
40004cf0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40004cf4: 30 80 00 35 b,a 40004dc8 <rtems_fdisk_erase_segment+0x174><== NOT EXECUTED
40004cf8: 02 80 00 34 be 40004dc8 <rtems_fdisk_erase_segment+0x174> <== NOT EXECUTED
40004cfc: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
40004d00: 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)
40004d04: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004d08: 12 bf ff fc bne 40004cf8 <rtems_fdisk_erase_segment+0xa4> <== NOT EXECUTED
40004d0c: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
40004d10: 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;
40004d14: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
40004d18: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
40004d1c: f2 27 60 5c st %i1, [ %i5 + 0x5c ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40004d20: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
40004d24: 82 00 60 01 inc %g1 <== NOT EXECUTED
40004d28: c2 27 60 60 st %g1, [ %i5 + 0x60 ] <== NOT EXECUTED
40004d2c: 81 c7 e0 08 ret <== NOT EXECUTED
40004d30: 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++;
40004d34: 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;
40004d38: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004d3c: d2 06 60 18 ld [ %i1 + 0x18 ], %o1
40004d40: 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++;
40004d44: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004d48: 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;
40004d4c: 84 00 c0 02 add %g3, %g2, %g2
40004d50: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004d54: 7f ff f6 19 call 400025b8 <.umul>
40004d58: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
40004d5c: 92 10 20 ff mov 0xff, %o1
40004d60: 94 10 00 08 mov %o0, %o2
40004d64: 40 00 7c 08 call 40023d84 <memset>
40004d68: 90 10 00 1c mov %i4, %o0
{
if (sc)
{
sc->next = 0;
if (queue->head)
40004d6c: 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;
40004d70: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
40004d74: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
40004d78: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
40004d7c: c0 26 60 28 clr [ %i1 + 0x28 ]
{
if (sc)
{
sc->next = 0;
if (queue->head)
40004d80: 80 a0 60 00 cmp %g1, 0
40004d84: 02 80 00 0a be 40004dac <rtems_fdisk_erase_segment+0x158>
40004d88: c0 26 40 00 clr [ %i1 ]
{
queue->tail->next = sc;
40004d8c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40004d90: f2 20 40 00 st %i1, [ %g1 ]
queue->tail = sc;
40004d94: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40004d98: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40004d9c: 82 00 60 01 inc %g1
40004da0: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
40004da4: 81 c7 e0 08 ret
40004da8: 81 e8 00 00 restore
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40004dac: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
40004db0: 10 bf ff fa b 40004d98 <rtems_fdisk_erase_segment+0x144>
40004db4: 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;
40004db8: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40004dbc: f2 27 60 5c st %i1, [ %i5 + 0x5c ] <== NOT EXECUTED
40004dc0: 10 bf ff d8 b 40004d20 <rtems_fdisk_erase_segment+0xcc> <== NOT EXECUTED
40004dc4: f2 27 60 58 st %i1, [ %i5 + 0x58 ] <== NOT EXECUTED
40004dc8: 81 c7 e0 08 ret <== NOT EXECUTED
40004dcc: 81 e8 00 00 restore <== NOT EXECUTED
40004bd8 <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, ...)
{
40004bd8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
40004bdc: 21 10 00 e4 sethi %hi(0x40039000), %l0 <== NOT EXECUTED
40004be0: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 ! 40039370 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
40004be4: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40004be8: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40004bec: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40004bf0: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40004bf4: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40004bf8: 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);
40004bfc: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40004c00: 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);
40004c04: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40004c08: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
40004c0c: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40004c10: 40 00 7b 46 call 40023928 <fwrite> <== NOT EXECUTED
40004c14: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 400343b0 <__FUNCTION__.6193+0x2e8><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
40004c18: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 <== NOT EXECUTED
40004c1c: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
40004c20: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
40004c24: 40 00 9c a6 call 4002bebc <vfprintf> <== NOT EXECUTED
40004c28: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
40004c2c: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
40004c30: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
40004c34: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40004c38: 40 00 79 5b call 400231a4 <fputc> <== NOT EXECUTED
40004c3c: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
40004c40: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 <== NOT EXECUTED
40004c44: 40 00 78 40 call 40022d44 <fflush> <== NOT EXECUTED
40004c48: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
40004c4c: 81 c7 e0 08 ret <== NOT EXECUTED
40004c50: 81 e8 00 00 restore <== NOT EXECUTED
400047e8 <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, ...)
{
400047e8: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
400047ec: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400047f0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400047f4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
400047f8: 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)
400047fc: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
40004800: 80 a0 60 01 cmp %g1, 1
40004804: 08 80 00 19 bleu 40004868 <rtems_fdisk_info+0x80> <== ALWAYS TAKEN
40004808: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
4000480c: 3b 10 00 e4 sethi %hi(0x40039000), %i5 <== NOT EXECUTED
40004810: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 ! 40039370 <_impure_ptr><== NOT EXECUTED
40004814: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40004818: 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);
4000481c: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
40004820: 94 10 20 06 mov 6, %o2 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
40004824: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
40004828: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
4000482c: 40 00 7c 3f call 40023928 <fwrite> <== NOT EXECUTED
40004830: 90 12 23 20 or %o0, 0x320, %o0 ! 40034320 <__FUNCTION__.6193+0x258><== NOT EXECUTED
ret = vfprintf (stdout, format, args);
40004834: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 <== NOT EXECUTED
40004838: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4000483c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40004840: 40 00 9d 9f call 4002bebc <vfprintf> <== NOT EXECUTED
40004844: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
40004848: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
4000484c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
40004850: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40004854: 40 00 7a 54 call 400231a4 <fputc> <== NOT EXECUTED
40004858: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
4000485c: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 <== NOT EXECUTED
40004860: 40 00 79 39 call 40022d44 <fflush> <== NOT EXECUTED
40004864: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40004868: 81 c7 e0 08 ret
4000486c: 81 e8 00 00 restore
4000706c <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
4000706c: 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 ();
40007070: 7f ff f5 05 call 40004484 <rtems_disk_io_initialize>
40007074: a4 10 00 18 mov %i0, %l2
if (sc != RTEMS_SUCCESSFUL)
40007078: b0 92 20 00 orcc %o0, 0, %i0
4000707c: 02 80 00 04 be 4000708c <rtems_fdisk_initialize+0x20> <== ALWAYS TAKEN
40007080: 01 00 00 00 nop
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
40007084: 81 c7 e0 08 ret <== NOT EXECUTED
40007088: 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);
4000708c: 40 00 05 4c call 400085bc <malloc>
40007090: 90 10 22 00 mov 0x200, %o0
40007094: 03 10 01 26 sethi %hi(0x40049800), %g1
40007098: d0 20 60 e0 st %o0, [ %g1 + 0xe0 ] ! 400498e0 <rtems_fdisk_crc16_factor>
if (!rtems_fdisk_crc16_factor)
4000709c: 80 a2 20 00 cmp %o0, 0
400070a0: 02 bf ff f9 be 40007084 <rtems_fdisk_initialize+0x18> <== NEVER TAKEN
400070a4: 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;
400070a8: 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)
400070ac: 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;
400070b0: 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;
400070b4: 82 10 00 03 mov %g3, %g1
400070b8: 84 10 20 08 mov 8, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
400070bc: 80 88 60 01 btst 1, %g1
400070c0: 83 28 60 10 sll %g1, 0x10, %g1
400070c4: 02 80 00 03 be 400070d0 <rtems_fdisk_initialize+0x64>
400070c8: 83 30 60 11 srl %g1, 0x11, %g1
400070cc: 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--;)
400070d0: 84 80 bf ff addcc %g2, -1, %g2
400070d4: 12 bf ff fb bne 400070c0 <rtems_fdisk_initialize+0x54>
400070d8: 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,
400070dc: 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++)
400070e0: 86 00 e0 01 inc %g3
400070e4: 80 a0 e1 00 cmp %g3, 0x100
400070e8: 12 bf ff f3 bne 400070b4 <rtems_fdisk_initialize+0x48>
400070ec: 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,
400070f0: 03 10 00 e4 sethi %hi(0x40039000), %g1
400070f4: fa 00 61 bc ld [ %g1 + 0x1bc ], %i5 ! 400391bc <rtems_flashdisk_configuration_size>
400070f8: 92 10 20 74 mov 0x74, %o1
400070fc: 90 10 00 1d mov %i5, %o0
40007100: 40 00 03 2f call 40007dbc <calloc>
40007104: 35 10 01 26 sethi %hi(0x40049800), %i2
40007108: d0 26 a0 d8 st %o0, [ %i2 + 0xd8 ] ! 400498d8 <rtems_flashdisks>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
4000710c: 80 a2 20 00 cmp %o0, 0
40007110: 02 bf ff dd be 40007084 <rtems_fdisk_initialize+0x18> <== NEVER TAKEN
40007114: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
40007118: 80 a7 60 00 cmp %i5, 0
4000711c: 02 80 00 f6 be 400074f4 <rtems_fdisk_initialize+0x488> <== NEVER TAKEN
40007120: 21 10 00 ce sethi %hi(0x40033800), %l0
40007124: a6 10 20 00 clr %l3
40007128: a0 14 23 50 or %l0, 0x350, %l0
4000712c: a2 10 20 00 clr %l1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
40007130: f8 04 20 0c ld [ %l0 + 0xc ], %i4
fd->compact_segs = c->compact_segs;
40007134: c8 04 20 14 ld [ %l0 + 0x14 ], %g4
fd->avail_compact_segs = c->avail_compact_segs;
40007138: c6 04 20 18 ld [ %l0 + 0x18 ], %g3
fd->block_size = c->block_size;
4000713c: fa 04 00 00 ld [ %l0 ], %i5
fd->unavail_blocks = c->unavail_blocks;
40007140: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
fd->info_level = c->info_level;
40007144: 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";
40007148: 35 00 00 18 sethi %hi(0x6000), %i2
4000714c: b4 16 a1 00 or %i2, 0x100, %i2 ! 6100 <PROM_START+0x6100>
40007150: 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++)
40007154: 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;
40007158: 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";
4000715c: 35 0b d9 19 sethi %hi(0x2f646400), %i2
40007160: 37 0b d9 99 sethi %hi(0x2f666400), %i3
40007164: b4 16 a1 76 or %i2, 0x176, %i2
40007168: b6 16 e0 64 or %i3, 0x64, %i3
4000716c: f4 3f bf f0 std %i2, [ %fp + -16 ]
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
40007170: 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];
40007174: b6 02 00 13 add %o0, %l3, %i3
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
40007178: e2 26 e0 04 st %l1, [ %i3 + 4 ]
fd->flags = c->flags;
4000717c: f8 26 e0 08 st %i4, [ %i3 + 8 ]
fd->compact_segs = c->compact_segs;
40007180: c8 26 e0 0c st %g4, [ %i3 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
40007184: c6 26 e0 10 st %g3, [ %i3 + 0x10 ]
fd->block_size = c->block_size;
40007188: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
4000718c: c4 26 e0 20 st %g2, [ %i3 + 0x20 ]
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
40007190: 80 a5 20 00 cmp %l4, 0
40007194: 02 80 00 a3 be 40007420 <rtems_fdisk_initialize+0x3b4> <== NEVER TAKEN
40007198: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
4000719c: 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,
400071a0: 83 2d 20 02 sll %l4, 2, %g1
400071a4: 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;
400071a8: 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,
400071ac: b0 26 00 01 sub %i0, %g1, %i0
400071b0: 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++)
400071b4: c4 06 80 00 ld [ %i2 ], %g2
400071b8: 80 a0 a0 00 cmp %g2, 0
400071bc: 02 80 00 93 be 40007408 <rtems_fdisk_initialize+0x39c> <== NEVER TAKEN
400071c0: 87 28 a0 02 sll %g2, 2, %g3
400071c4: 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,
400071c8: 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;
400071cc: 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,
400071d0: b8 27 00 03 sub %i4, %g3, %i4
400071d4: 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;
400071d8: d0 05 60 08 ld [ %l5 + 8 ], %o0
400071dc: 7f ff ed 31 call 400026a0 <.udiv>
400071e0: 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;
400071e4: 92 10 00 1d mov %i5, %o1
400071e8: 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);
400071ec: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
400071f0: 7f ff ed 2c call 400026a0 <.udiv>
400071f4: 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;
400071f8: d2 15 40 00 lduh [ %l5 ], %o1
400071fc: 7f ff ec ef call 400025b8 <.umul>
40007200: 90 25 80 08 sub %l6, %o0, %o0
40007204: 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++)
40007208: 80 a5 40 1c cmp %l5, %i4
4000720c: 12 bf ff f3 bne 400071d8 <rtems_fdisk_initialize+0x16c> <== NEVER TAKEN
40007210: ae 05 c0 08 add %l7, %o0, %l7
40007214: 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++)
40007218: 80 a6 80 18 cmp %i2, %i0
4000721c: 12 bf ff e6 bne 400071b4 <rtems_fdisk_initialize+0x148> <== NEVER TAKEN
40007220: 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);
40007224: 40 00 04 e6 call 400085bc <malloc>
40007228: 90 10 00 1d mov %i5, %o0
if (!fd->copy_buffer)
4000722c: 80 a2 20 00 cmp %o0, 0
40007230: 02 80 00 af be 400074ec <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
40007234: d0 26 e0 68 st %o0, [ %i3 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
40007238: 90 10 00 19 mov %i1, %o0
4000723c: 40 00 02 e0 call 40007dbc <calloc>
40007240: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
40007244: 80 a2 20 00 cmp %o0, 0
40007248: 02 80 00 a9 be 400074ec <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
4000724c: d0 26 e0 18 st %o0, [ %i3 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
40007250: f2 26 e0 1c st %i1, [ %i3 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40007254: 90 10 00 14 mov %l4, %o0
40007258: 40 00 02 d9 call 40007dbc <calloc>
4000725c: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
40007260: 80 a2 20 00 cmp %o0, 0
40007264: 02 80 00 a2 be 400074ec <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
40007268: d0 26 e0 2c st %o0, [ %i3 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
4000726c: 03 10 00 d3 sethi %hi(0x40034c00), %g1
40007270: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 40034ec8 <__FUNCTION__.6193+0xe00>
40007274: 92 10 20 01 mov 1, %o1
40007278: 94 10 20 54 mov 0x54, %o2
4000727c: 96 10 20 00 clr %o3
40007280: 40 00 15 f2 call 4000ca48 <rtems_semaphore_create>
40007284: 98 06 e0 64 add %i3, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
40007288: b0 92 20 00 orcc %o0, 0, %i0
4000728c: 12 80 00 8d bne 400074c0 <rtems_fdisk_initialize+0x454> <== NEVER TAKEN
40007290: 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,
40007294: d6 06 e0 20 ld [ %i3 + 0x20 ], %o3
40007298: d4 04 00 00 ld [ %l0 ], %o2
4000729c: 90 10 00 12 mov %l2, %o0
400072a0: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
400072a4: 92 10 00 11 mov %l1, %o1
400072a8: 96 26 40 0b sub %i1, %o3, %o3
400072ac: 19 10 00 17 sethi %hi(0x40005c00), %o4
400072b0: 9a 10 20 00 clr %o5
400072b4: 7f ff f3 d4 call 40004204 <rtems_disk_create_phys>
400072b8: 98 13 20 54 or %o4, 0x54, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
400072bc: b0 92 20 00 orcc %o0, 0, %i0
400072c0: 12 80 00 70 bne 40007480 <rtems_fdisk_initialize+0x414> <== NEVER TAKEN
400072c4: 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++)
400072c8: f0 04 20 04 ld [ %l0 + 4 ], %i0
400072cc: 80 a6 20 00 cmp %i0, 0
400072d0: 22 80 00 3b be,a 400073bc <rtems_fdisk_initialize+0x350> <== NEVER TAKEN
400072d4: f0 26 e0 30 st %i0, [ %i3 + 0x30 ] <== NOT EXECUTED
400072d8: f4 04 20 08 ld [ %l0 + 8 ], %i2
400072dc: f2 06 e0 2c ld [ %i3 + 0x2c ], %i1
400072e0: 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++)
400072e4: c4 06 80 00 ld [ %i2 ], %g2
400072e8: 80 a0 a0 00 cmp %g2, 0
400072ec: 02 80 00 5d be 40007460 <rtems_fdisk_initialize+0x3f4> <== NEVER TAKEN
400072f0: a9 28 a0 02 sll %g2, 2, %l4
400072f4: 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;
400072f8: 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,
400072fc: 85 28 a0 04 sll %g2, 4, %g2
40007300: 88 20 80 14 sub %g2, %l4, %g4
40007304: 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;
40007308: c6 10 40 00 lduh [ %g1 ], %g3
4000730c: 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++)
40007310: 80 a0 40 04 cmp %g1, %g4
40007314: 12 bf ff fd bne 40007308 <rtems_fdisk_initialize+0x29c> <== NEVER TAKEN
40007318: 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,
4000731c: c4 27 bf ec st %g2, [ %fp + -20 ]
40007320: 90 10 00 1c mov %i4, %o0
40007324: 40 00 02 a6 call 40007dbc <calloc>
40007328: 92 10 20 30 mov 0x30, %o1
4000732c: d0 26 40 00 st %o0, [ %i1 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40007330: 80 a2 20 00 cmp %o0, 0
40007334: 02 80 00 3d be 40007428 <rtems_fdisk_initialize+0x3bc> <== NEVER TAKEN
40007338: c4 07 bf ec ld [ %fp + -20 ], %g2
4000733c: 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,
40007340: 84 20 80 14 sub %g2, %l4, %g2
40007344: 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++)
40007348: c8 10 c0 00 lduh [ %g3 ], %g4
4000734c: 80 a1 20 00 cmp %g4, 0
40007350: 02 80 00 0f be 4000738c <rtems_fdisk_initialize+0x320> <== NEVER TAKEN
40007354: 82 10 00 08 mov %o0, %g1
40007358: 84 10 20 00 clr %g2
{
sc->descriptor = sd;
sc->device = device;
sc->segment = seg_segment;
4000735c: 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;
40007360: c6 20 60 04 st %g3, [ %g1 + 4 ]
sc->device = device;
40007364: fa 20 60 08 st %i5, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
40007368: 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++)
4000736c: 84 00 a0 01 inc %g2
40007370: 80 a0 80 04 cmp %g2, %g4
40007374: 0a bf ff fa bcs 4000735c <rtems_fdisk_initialize+0x2f0>
40007378: 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,
4000737c: 83 29 20 04 sll %g4, 4, %g1
40007380: 89 29 20 06 sll %g4, 6, %g4
40007384: 88 21 00 01 sub %g4, %g1, %g4
40007388: 90 02 00 04 add %o0, %g4, %o0
4000738c: 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++)
40007390: 80 a0 c0 0f cmp %g3, %o7
40007394: 32 bf ff ee bne,a 4000734c <rtems_fdisk_initialize+0x2e0><== NEVER TAKEN
40007398: 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];
4000739c: f4 26 60 08 st %i2, [ %i1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
400073a0: 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++)
400073a4: ba 07 60 01 inc %i5
400073a8: b4 06 a0 0c add %i2, 0xc, %i2
400073ac: 80 a7 40 18 cmp %i5, %i0
400073b0: 12 bf ff cd bne 400072e4 <rtems_fdisk_initialize+0x278> <== NEVER TAKEN
400073b4: 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;
400073b8: f0 26 e0 30 st %i0, [ %i3 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
400073bc: 7f ff f9 31 call 40005880 <rtems_fdisk_recover_block_mappings>
400073c0: 90 10 00 1b mov %i3, %o0
if (ret)
400073c4: b0 92 20 00 orcc %o0, 0, %i0
400073c8: 12 80 00 63 bne 40007554 <rtems_fdisk_initialize+0x4e8> <== NEVER TAKEN
400073cc: 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);
400073d0: 7f ff f8 76 call 400055a8 <rtems_fdisk_compact>
400073d4: 90 10 00 1b mov %i3, %o0
if (ret)
400073d8: b0 92 20 00 orcc %o0, 0, %i0
400073dc: 12 80 00 4a bne 40007504 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
400073e0: 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++)
400073e4: 37 10 00 e4 sethi %hi(0x40039000), %i3
400073e8: fa 06 e1 bc ld [ %i3 + 0x1bc ], %i5 ! 400391bc <rtems_flashdisk_configuration_size>
400073ec: a2 04 60 01 inc %l1
400073f0: 80 a7 40 11 cmp %i5, %l1
400073f4: 08 80 00 40 bleu 400074f4 <rtems_fdisk_initialize+0x488> <== ALWAYS TAKEN
400073f8: a6 04 e0 74 add %l3, 0x74, %l3
400073fc: 03 10 01 26 sethi %hi(0x40049800), %g1 <== NOT EXECUTED
40007400: 10 bf ff 4c b 40007130 <rtems_fdisk_initialize+0xc4> <== NOT EXECUTED
40007404: d0 00 60 d8 ld [ %g1 + 0xd8 ], %o0 ! 400498d8 <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;
40007408: ae 10 20 00 clr %l7 <== NOT EXECUTED
4000740c: 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++)
40007410: 80 a6 80 18 cmp %i2, %i0 <== NOT EXECUTED
40007414: 12 bf ff 68 bne 400071b4 <rtems_fdisk_initialize+0x148> <== NOT EXECUTED
40007418: b2 06 40 17 add %i1, %l7, %i1 <== NOT EXECUTED
4000741c: 30 bf ff 82 b,a 40007224 <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;
40007420: 10 bf ff 81 b 40007224 <rtems_fdisk_initialize+0x1b8> <== NOT EXECUTED
40007424: 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);
40007428: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000742c: 7f ff f2 c5 call 40003f40 <rtems_disk_delete> <== NOT EXECUTED
40007430: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40007434: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
40007438: 40 00 15 f5 call 4000cc0c <rtems_semaphore_delete> <== NOT EXECUTED
4000743c: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
free (fd->copy_buffer);
40007440: 40 00 02 c2 call 40007f48 <free> <== NOT EXECUTED
40007444: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007448: 40 00 02 c0 call 40007f48 <free> <== NOT EXECUTED
4000744c: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007450: 40 00 02 be call 40007f48 <free> <== NOT EXECUTED
40007454: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
40007458: 81 c7 e0 08 ret <== NOT EXECUTED
4000745c: 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,
40007460: 90 10 20 00 clr %o0 <== NOT EXECUTED
40007464: 40 00 02 56 call 40007dbc <calloc> <== NOT EXECUTED
40007468: 92 10 20 30 mov 0x30, %o1 <== NOT EXECUTED
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
4000746c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40007470: 02 bf ff ee be 40007428 <rtems_fdisk_initialize+0x3bc> <== NOT EXECUTED
40007474: 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;
40007478: 10 bf ff c9 b 4000739c <rtems_fdisk_initialize+0x330> <== NOT EXECUTED
4000747c: 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);
40007480: 40 00 15 e3 call 4000cc0c <rtems_semaphore_delete> <== NOT EXECUTED
40007484: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
40007488: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000748c: 7f ff f2 ad call 40003f40 <rtems_disk_delete> <== NOT EXECUTED
40007490: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007494: 40 00 02 ad call 40007f48 <free> <== NOT EXECUTED
40007498: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
4000749c: 40 00 02 ab call 40007f48 <free> <== NOT EXECUTED
400074a0: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
400074a4: 40 00 02 a9 call 40007f48 <free> <== NOT EXECUTED
400074a8: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
400074ac: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
400074b0: 7f ff f5 ca call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
400074b4: 90 12 22 60 or %o0, 0x260, %o0 ! 40034e60 <__FUNCTION__.6193+0xd98><== NOT EXECUTED
400074b8: 81 c7 e0 08 ret <== NOT EXECUTED
400074bc: 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");
400074c0: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
400074c4: 7f ff f5 c5 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
400074c8: 90 12 22 48 or %o0, 0x248, %o0 ! 40034e48 <__FUNCTION__.6193+0xd80><== NOT EXECUTED
free (fd->copy_buffer);
400074cc: 40 00 02 9f call 40007f48 <free> <== NOT EXECUTED
400074d0: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
400074d4: 40 00 02 9d call 40007f48 <free> <== NOT EXECUTED
400074d8: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
400074dc: 40 00 02 9b call 40007f48 <free> <== NOT EXECUTED
400074e0: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
400074e4: 81 c7 e0 08 ret <== NOT EXECUTED
400074e8: 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;
400074ec: 81 c7 e0 08 ret <== NOT EXECUTED
400074f0: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
400074f4: 03 10 01 26 sethi %hi(0x40049800), %g1
400074f8: fa 20 60 dc st %i5, [ %g1 + 0xdc ] ! 400498dc <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
400074fc: 81 c7 e0 08 ret
40007500: 91 e8 20 00 restore %g0, 0, %o0
}
ret = rtems_fdisk_compact (fd);
if (ret)
{
rtems_disk_delete (dev);
40007504: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
40007508: 7f ff f2 8e call 40003f40 <rtems_disk_delete> <== NOT EXECUTED
4000750c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40007510: 40 00 15 bf call 4000cc0c <rtems_semaphore_delete> <== NOT EXECUTED
40007514: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007518: 40 00 02 8c call 40007f48 <free> <== NOT EXECUTED
4000751c: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40007520: 40 00 02 8a call 40007f48 <free> <== NOT EXECUTED
40007524: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007528: 40 00 02 88 call 40007f48 <free> <== NOT EXECUTED
4000752c: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
40007530: 40 00 76 dd call 400250a4 <strerror> <== NOT EXECUTED
40007534: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40007538: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4000753c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40007540: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
40007544: 7f ff f5 a5 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40007548: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 40034ea0 <__FUNCTION__.6193+0xdd8><== NOT EXECUTED
4000754c: 81 c7 e0 08 ret <== NOT EXECUTED
40007550: 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);
40007554: 7f ff f2 7b call 40003f40 <rtems_disk_delete> <== NOT EXECUTED
40007558: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
4000755c: 40 00 15 ac call 4000cc0c <rtems_semaphore_delete> <== NOT EXECUTED
40007560: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40007564: 40 00 02 79 call 40007f48 <free> <== NOT EXECUTED
40007568: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
4000756c: 40 00 02 77 call 40007f48 <free> <== NOT EXECUTED
40007570: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40007574: 40 00 02 75 call 40007f48 <free> <== NOT EXECUTED
40007578: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
4000757c: 40 00 76 ca call 400250a4 <strerror> <== NOT EXECUTED
40007580: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40007584: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40007588: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4000758c: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
40007590: 7f ff f5 92 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40007594: 90 12 22 78 or %o0, 0x278, %o0 ! 40034e78 <__FUNCTION__.6193+0xdb0><== NOT EXECUTED
40007598: 81 c7 e0 08 ret <== NOT EXECUTED
4000759c: 81 e8 00 00 restore <== NOT EXECUTED
40005c54 <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)
{
40005c54: 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;
40005c58: 40 00 73 38 call 40022938 <__errno>
40005c5c: fa 06 20 04 ld [ %i0 + 4 ], %i5
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40005c60: 21 10 01 26 sethi %hi(0x40049800), %l0
40005c64: c2 04 20 d8 ld [ %l0 + 0xd8 ], %g1 ! 400498d8 <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;
40005c68: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40005c6c: 87 2f 60 05 sll %i5, 5, %g3
40005c70: 85 2f 60 02 sll %i5, 2, %g2
40005c74: 84 20 c0 02 sub %g3, %g2, %g2
40005c78: 84 00 80 1d add %g2, %i5, %g2
40005c7c: ab 28 a0 02 sll %g2, 2, %l5
40005c80: 82 00 40 15 add %g1, %l5, %g1
40005c84: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
40005c88: 92 10 20 00 clr %o1
40005c8c: 40 00 1c 17 call 4000cce8 <rtems_semaphore_obtain>
40005c90: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40005c94: 80 a2 20 00 cmp %o0, 0
40005c98: 12 80 00 36 bne 40005d70 <rtems_fdisk_ioctl+0x11c> <== NEVER TAKEN
40005c9c: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
40005ca0: 40 00 73 26 call 40022938 <__errno>
40005ca4: 01 00 00 00 nop
switch (req)
40005ca8: 03 08 00 10 sethi %hi(0x20004000), %g1
40005cac: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_SIZE+0x1fc04283>
40005cb0: 80 a6 40 02 cmp %i1, %g2
40005cb4: 02 80 00 5b be 40005e20 <rtems_fdisk_ioctl+0x1cc> <== NEVER TAKEN
40005cb8: c0 22 00 00 clr [ %o0 ]
40005cbc: 80 a6 40 02 cmp %i1, %g2
40005cc0: 38 80 00 37 bgu,a 40005d9c <rtems_fdisk_ioctl+0x148>
40005cc4: 82 10 62 85 or %g1, 0x285, %g1
40005cc8: 84 10 62 81 or %g1, 0x281, %g2
40005ccc: 80 a6 40 02 cmp %i1, %g2
40005cd0: 02 80 00 de be 40006048 <rtems_fdisk_ioctl+0x3f4> <== NEVER TAKEN
40005cd4: 01 00 00 00 nop
40005cd8: 08 80 00 d0 bleu 40006018 <rtems_fdisk_ioctl+0x3c4> <== ALWAYS TAKEN
40005cdc: 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]);
40005ce0: 40 00 73 16 call 40022938 <__errno> <== NOT EXECUTED
40005ce4: b8 10 20 00 clr %i4 <== NOT EXECUTED
40005ce8: fa 04 20 d8 ld [ %l0 + 0xd8 ], %i5 <== NOT EXECUTED
40005cec: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
40005cf0: 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)
40005cf4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
40005cf8: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED
40005cfc: 02 80 00 15 be 40005d50 <rtems_fdisk_ioctl+0xfc> <== NOT EXECUTED
40005d00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
40005d04: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
if (!queue->head)
40005d08: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40005d0c: 02 80 01 09 be 40006130 <rtems_fdisk_ioctl+0x4dc> <== NOT EXECUTED
40005d10: c4 27 60 4c st %g2, [ %i5 + 0x4c ] <== NOT EXECUTED
queue->tail = 0;
queue->count--;
40005d14: c4 07 60 54 ld [ %i5 + 0x54 ], %g2 <== NOT EXECUTED
40005d18: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
40005d1c: 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);
40005d20: 7f ff fb cd call 40004c54 <rtems_fdisk_erase_segment> <== NOT EXECUTED
40005d24: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
if (ret && !latched_ret)
40005d28: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005d2c: 02 bf ff f3 be 40005cf8 <rtems_fdisk_ioctl+0xa4> <== NOT EXECUTED
40005d30: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
40005d34: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40005d38: 12 bf ff f0 bne 40005cf8 <rtems_fdisk_ioctl+0xa4> <== NOT EXECUTED
40005d3c: 01 00 00 00 nop <== NOT EXECUTED
40005d40: 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)
40005d44: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED
40005d48: 12 bf ff ef bne 40005d04 <rtems_fdisk_ioctl+0xb0> <== NOT EXECUTED
40005d4c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005d50: c4 04 20 d8 ld [ %l0 + 0xd8 ], %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]);
40005d54: f8 26 c0 00 st %i4, [ %i3 ] <== NOT EXECUTED
40005d58: 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);
40005d5c: 40 00 1c 32 call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40005d60: d0 00 a0 64 ld [ %g2 + 0x64 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40005d64: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005d68: 02 80 00 06 be 40005d80 <rtems_fdisk_ioctl+0x12c> <== NOT EXECUTED
40005d6c: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
40005d70: 40 00 72 f2 call 40022938 <__errno> <== NOT EXECUTED
40005d74: 01 00 00 00 nop <== NOT EXECUTED
40005d78: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40005d7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
40005d80: 40 00 72 ee call 40022938 <__errno> <== NOT EXECUTED
40005d84: 01 00 00 00 nop <== NOT EXECUTED
40005d88: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
40005d8c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
40005d90: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
40005d94: 81 c7 e0 08 ret <== NOT EXECUTED
40005d98: 81 e8 00 00 restore <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
40005d9c: 80 a6 40 01 cmp %i1, %g1
40005da0: 02 80 00 e6 be 40006138 <rtems_fdisk_ioctl+0x4e4>
40005da4: 01 00 00 00 nop
40005da8: 0a 80 00 a5 bcs 4000603c <rtems_fdisk_ioctl+0x3e8> <== NEVER TAKEN
40005dac: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2
40005db0: 03 30 06 10 sethi %hi(0xc0184000), %g1
40005db4: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40005db8: 80 a6 40 01 cmp %i1, %g1
40005dbc: 12 80 00 9a bne 40006024 <rtems_fdisk_ioctl+0x3d0>
40005dc0: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40005dc4: 03 10 01 26 sethi %hi(0x40049800), %g1
40005dc8: c2 00 60 dc ld [ %g1 + 0xdc ], %g1 ! 400498dc <rtems_flashdisk_count>
40005dcc: 80 a0 40 1d cmp %g1, %i5
40005dd0: 08 80 02 0b bleu 400065fc <rtems_fdisk_ioctl+0x9a8> <== NEVER TAKEN
40005dd4: c2 04 20 d8 ld [ %l0 + 0xd8 ], %g1
(rtems_flashdisks[minor].device_count == 0))
40005dd8: 82 00 40 15 add %g1, %l5, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40005ddc: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
40005de0: 80 a0 60 00 cmp %g1, 0
40005de4: 02 80 02 06 be 400065fc <rtems_fdisk_ioctl+0x9a8> <== NEVER TAKEN
40005de8: 01 00 00 00 nop
{
errno = ENODEV;
}
else
{
switch (r->req)
40005dec: c2 06 80 00 ld [ %i2 ], %g1
40005df0: 80 a0 60 00 cmp %g1, 0
40005df4: 02 80 03 b0 be 40006cb4 <rtems_fdisk_ioctl+0x1060>
40005df8: 80 a0 60 01 cmp %g1, 1
40005dfc: 02 80 02 09 be 40006620 <rtems_fdisk_ioctl+0x9cc> <== ALWAYS TAKEN
40005e00: 01 00 00 00 nop
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
break;
default:
errno = EINVAL;
40005e04: 40 00 72 cd call 40022938 <__errno> <== NOT EXECUTED
40005e08: 01 00 00 00 nop <== NOT EXECUTED
40005e0c: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
40005e10: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40005e14: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
break;
40005e18: 10 80 00 74 b 40005fe8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
40005e1c: 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],
40005e20: 40 00 72 c6 call 40022938 <__errno> <== NOT EXECUTED
40005e24: 01 00 00 00 nop <== NOT EXECUTED
40005e28: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
40005e2c: 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;
40005e30: 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;
40005e34: fa 00 a0 14 ld [ %g2 + 0x14 ], %i5 <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
40005e38: c8 00 a0 20 ld [ %g2 + 0x20 ], %g4 <== NOT EXECUTED
data->device_count = fd->device_count;
40005e3c: 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;
40005e40: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
40005e44: c6 26 a0 04 st %g3, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
40005e48: c8 26 a0 08 st %g4, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
40005e4c: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
40005e50: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40005e54: 02 80 00 0f be 40005e90 <rtems_fdisk_ioctl+0x23c> <== NOT EXECUTED
40005e58: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
40005e5c: 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)
40005e60: 89 28 e0 03 sll %g3, 3, %g4 <== NOT EXECUTED
40005e64: 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)
40005e68: f8 07 40 03 ld [ %i5 + %g3 ], %i4 <== NOT EXECUTED
40005e6c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40005e70: 02 80 00 05 be 40005e84 <rtems_fdisk_ioctl+0x230> <== NOT EXECUTED
40005e74: 86 00 e0 08 add %g3, 8, %g3 <== NOT EXECUTED
data->blocks_used++;
40005e78: f8 06 a0 18 ld [ %i2 + 0x18 ], %i4 <== NOT EXECUTED
40005e7c: b8 07 20 01 inc %i4 <== NOT EXECUTED
40005e80: 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++)
40005e84: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED
40005e88: 32 bf ff f9 bne,a 40005e6c <rtems_fdisk_ioctl+0x218> <== NOT EXECUTED
40005e8c: 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;
40005e90: c8 00 a0 34 ld [ %g2 + 0x34 ], %g4 <== NOT EXECUTED
uint32_t count = 0;
while (sc)
40005e94: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40005e98: 02 80 00 06 be 40005eb0 <rtems_fdisk_ioctl+0x25c> <== NOT EXECUTED
40005e9c: 86 10 20 00 clr %g3 <== NOT EXECUTED
{
count++;
sc = sc->next;
40005ea0: 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)
40005ea4: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40005ea8: 12 bf ff fe bne 40005ea0 <rtems_fdisk_ioctl+0x24c> <== NOT EXECUTED
40005eac: 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;
40005eb0: 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);
40005eb4: 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)
40005eb8: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40005ebc: 02 80 00 06 be 40005ed4 <rtems_fdisk_ioctl+0x280> <== NOT EXECUTED
40005ec0: 86 10 20 00 clr %g3 <== NOT EXECUTED
{
count++;
sc = sc->next;
40005ec4: 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)
40005ec8: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40005ecc: 12 bf ff fe bne 40005ec4 <rtems_fdisk_ioctl+0x270> <== NOT EXECUTED
40005ed0: 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;
40005ed4: 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);
40005ed8: 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)
40005edc: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40005ee0: 02 80 00 06 be 40005ef8 <rtems_fdisk_ioctl+0x2a4> <== NOT EXECUTED
40005ee4: 86 10 20 00 clr %g3 <== NOT EXECUTED
{
count++;
sc = sc->next;
40005ee8: 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)
40005eec: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40005ef0: 12 bf ff fe bne 40005ee8 <rtems_fdisk_ioctl+0x294> <== NOT EXECUTED
40005ef4: 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);
40005ef8: c6 26 a0 24 st %g3, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
40005efc: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
40005f00: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
40005f04: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
40005f08: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
40005f0c: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
40005f10: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
40005f14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005f18: 02 80 00 31 be 40005fdc <rtems_fdisk_ioctl+0x388> <== NOT EXECUTED
40005f1c: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
40005f20: 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)
40005f24: 87 28 60 02 sll %g1, 2, %g3 <== NOT EXECUTED
40005f28: a2 10 20 00 clr %l1 <== NOT EXECUTED
40005f2c: 83 28 60 04 sll %g1, 4, %g1 <== NOT EXECUTED
40005f30: a4 20 40 03 sub %g1, %g3, %l2 <== NOT EXECUTED
40005f34: 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;
40005f38: f0 04 20 04 ld [ %l0 + 4 ], %i0 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
40005f3c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40005f40: 02 80 00 22 be 40005fc8 <rtems_fdisk_ioctl+0x374> <== NOT EXECUTED
40005f44: a2 04 40 18 add %l1, %i0, %l1 <== NOT EXECUTED
40005f48: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
40005f4c: f2 06 a0 14 ld [ %i2 + 0x14 ], %i1 <== NOT EXECUTED
40005f50: f6 06 a0 2c ld [ %i2 + 0x2c ], %i3 <== NOT EXECUTED
40005f54: f8 06 a0 30 ld [ %i2 + 0x30 ], %i4 <== NOT EXECUTED
40005f58: fa 06 a0 34 ld [ %i2 + 0x34 ], %i5 <== NOT EXECUTED
40005f5c: c8 06 a0 38 ld [ %i2 + 0x38 ], %g4 <== NOT EXECUTED
40005f60: 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)
40005f64: 9f 2e 20 04 sll %i0, 4, %o7 <== NOT EXECUTED
40005f68: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
40005f6c: 92 26 00 0f sub %i0, %o7, %o1 <== NOT EXECUTED
40005f70: 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;
40005f74: d4 00 60 14 ld [ %g1 + 0x14 ], %o2 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40005f78: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
data->pages_active += sc->pages_active;
40005f7c: d8 00 60 1c ld [ %g1 + 0x1c ], %o4 <== NOT EXECUTED
data->pages_used += sc->pages_used;
40005f80: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
40005f84: de 00 60 24 ld [ %g1 + 0x24 ], %o7 <== NOT EXECUTED
data->seg_erases += sc->erased;
40005f88: 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;
40005f8c: b2 06 40 0a add %i1, %o2, %i1 <== NOT EXECUTED
40005f90: 82 00 60 30 add %g1, 0x30, %g1 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40005f94: b6 06 c0 0b add %i3, %o3, %i3 <== NOT EXECUTED
data->pages_active += sc->pages_active;
40005f98: b8 07 00 0c add %i4, %o4, %i4 <== NOT EXECUTED
data->pages_used += sc->pages_used;
40005f9c: ba 07 40 0d add %i5, %o5, %i5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
40005fa0: 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++)
40005fa4: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
40005fa8: 12 bf ff f3 bne 40005f74 <rtems_fdisk_ioctl+0x320> <== NOT EXECUTED
40005fac: 86 00 c0 18 add %g3, %i0, %g3 <== NOT EXECUTED
40005fb0: f2 26 a0 14 st %i1, [ %i2 + 0x14 ] <== NOT EXECUTED
40005fb4: f6 26 a0 2c st %i3, [ %i2 + 0x2c ] <== NOT EXECUTED
40005fb8: f8 26 a0 30 st %i4, [ %i2 + 0x30 ] <== NOT EXECUTED
40005fbc: fa 26 a0 34 st %i5, [ %i2 + 0x34 ] <== NOT EXECUTED
40005fc0: c8 26 a0 38 st %g4, [ %i2 + 0x38 ] <== NOT EXECUTED
40005fc4: c6 26 a0 28 st %g3, [ %i2 + 0x28 ] <== NOT EXECUTED
40005fc8: 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++)
40005fcc: 80 a4 00 12 cmp %l0, %l2 <== NOT EXECUTED
40005fd0: 32 bf ff db bne,a 40005f3c <rtems_fdisk_ioctl+0x2e8> <== NOT EXECUTED
40005fd4: f0 04 20 04 ld [ %l0 + 4 ], %i0 <== NOT EXECUTED
40005fd8: 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;
40005fdc: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 <== NOT EXECUTED
40005fe0: 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],
40005fe4: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
40005fe8: 40 00 1b 8f call 4000ce24 <rtems_semaphore_release>
40005fec: d0 00 a0 64 ld [ %g2 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40005ff0: 80 a2 20 00 cmp %o0, 0
40005ff4: 12 bf ff 5f bne 40005d70 <rtems_fdisk_ioctl+0x11c> <== NEVER TAKEN
40005ff8: 01 00 00 00 nop
errno = EIO;
}
return errno == 0 ? 0 : -1;
40005ffc: 40 00 72 4f call 40022938 <__errno>
40006000: 01 00 00 00 nop
40006004: c2 02 00 00 ld [ %o0 ], %g1
40006008: 80 a0 00 01 cmp %g0, %g1
4000600c: b0 60 20 00 subx %g0, 0, %i0
40006010: 81 c7 e0 08 ret
40006014: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
40006018: 80 a6 40 01 cmp %i1, %g1
4000601c: 02 80 00 15 be 40006070 <rtems_fdisk_ioctl+0x41c> <== NEVER TAKEN
40006020: 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);
40006024: 92 10 00 19 mov %i1, %o1
40006028: 40 00 42 c0 call 40016b28 <rtems_blkdev_ioctl>
4000602c: 94 10 00 1a mov %i2, %o2
40006030: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2
break;
40006034: 10 bf ff ed b 40005fe8 <rtems_fdisk_ioctl+0x394>
40006038: 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;
4000603c: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
break;
40006040: 10 bf ff ea b 40005fe8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
40006044: 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]);
40006048: 40 00 72 3c call 40022938 <__errno> <== NOT EXECUTED
4000604c: 01 00 00 00 nop <== NOT EXECUTED
40006050: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40006054: d0 04 20 d8 ld [ %l0 + 0xd8 ], %o0 <== NOT EXECUTED
40006058: 7f ff fd 54 call 400055a8 <rtems_fdisk_compact> <== NOT EXECUTED
4000605c: 90 02 00 15 add %o0, %l5, %o0 <== NOT EXECUTED
40006060: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
40006064: d0 27 40 00 st %o0, [ %i5 ] <== NOT EXECUTED
break;
40006068: 10 bf ff e0 b 40005fe8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
4000606c: 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]);
40006070: 40 00 72 32 call 40022938 <__errno> <== NOT EXECUTED
40006074: 01 00 00 00 nop <== NOT EXECUTED
40006078: fa 04 20 d8 ld [ %l0 + 0xd8 ], %i5 <== NOT EXECUTED
4000607c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
40006080: 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");
40006084: 13 10 00 d3 sethi %hi(0x40034c00), %o1 <== NOT EXECUTED
40006088: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000608c: 7f ff f9 d7 call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
40006090: 92 12 60 18 or %o1, 0x18, %o1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
40006094: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40006098: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000609c: 02 80 03 e3 be 40007028 <rtems_fdisk_ioctl+0x13d4> <== NOT EXECUTED
400060a0: 31 10 00 d3 sethi %hi(0x40034c00), %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);
400060a4: 33 10 00 d3 sethi %hi(0x40034c00), %i1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
400060a8: b6 10 20 00 clr %i3 <== NOT EXECUTED
400060ac: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
400060b0: b0 16 20 28 or %i0, 0x28, %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);
400060b4: 10 80 00 06 b 400060cc <rtems_fdisk_ioctl+0x478> <== NOT EXECUTED
400060b8: b2 16 60 40 or %i1, 0x40, %i1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
400060bc: b8 07 20 01 inc %i4 <== NOT EXECUTED
400060c0: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
400060c4: 1a 80 03 be bcc 40006fbc <rtems_fdisk_ioctl+0x1368> <== NOT EXECUTED
400060c8: b6 06 e0 0c add %i3, 0xc, %i3 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
400060cc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400060d0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400060d4: 7f ff f9 c5 call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
400060d8: 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;
400060dc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400060e0: 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;
400060e4: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
400060e8: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400060ec: 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;
400060f0: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400060f4: 7f ff f9 df call 40004870 <rtems_fdisk_printf> <== NOT EXECUTED
400060f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
400060fc: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
40006100: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
40006104: 84 00 80 1b add %g2, %i3, %g2 <== NOT EXECUTED
40006108: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
4000610c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006110: 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)
40006114: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006118: 22 bf ff e9 be,a 400060bc <rtems_fdisk_ioctl+0x468> <== NOT EXECUTED
4000611c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40006120: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
40006124: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
break;
40006128: 10 bf ff b0 b 40005fe8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
4000612c: 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;
40006130: 10 bf fe f9 b 40005d14 <rtems_fdisk_ioctl+0xc0> <== NOT EXECUTED
40006134: 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]);
40006138: 40 00 72 00 call 40022938 <__errno>
4000613c: ba 10 20 00 clr %i5
40006140: c2 04 20 d8 ld [ %l0 + 0xd8 ], %g1
40006144: d0 27 bf e8 st %o0, [ %fp + -24 ]
40006148: b6 00 40 15 add %g1, %l5, %i3
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
4000614c: 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;
40006150: c4 06 e0 6c ld [ %i3 + 0x6c ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
40006154: 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;
40006158: 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;
4000615c: c4 27 bf e4 st %g2, [ %fp + -28 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
40006160: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
rtems_fdisk_printf (fd,
40006164: 90 10 00 1b mov %i3, %o0
40006168: 13 10 00 d3 sethi %hi(0x40034c00), %o1
4000616c: 7f ff f9 c1 call 40004870 <rtems_fdisk_printf>
40006170: 92 12 60 58 or %o1, 0x58, %o1 ! 40034c58 <__FUNCTION__.6193+0xb90>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
40006174: d4 06 e0 1c ld [ %i3 + 0x1c ], %o2
40006178: 90 10 00 1b mov %i3, %o0
4000617c: 13 10 00 d3 sethi %hi(0x40034c00), %o1
40006180: 7f ff f9 bc call 40004870 <rtems_fdisk_printf>
40006184: 92 12 60 80 or %o1, 0x80, %o1 ! 40034c80 <__FUNCTION__.6193+0xbb8>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
40006188: d4 06 e0 20 ld [ %i3 + 0x20 ], %o2
4000618c: 90 10 00 1b mov %i3, %o0
40006190: 13 10 00 d3 sethi %hi(0x40034c00), %o1
40006194: 7f ff f9 b7 call 40004870 <rtems_fdisk_printf>
40006198: 92 12 60 90 or %o1, 0x90, %o1 ! 40034c90 <__FUNCTION__.6193+0xbc8>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
4000619c: d4 06 e0 24 ld [ %i3 + 0x24 ], %o2
400061a0: 90 10 00 1b mov %i3, %o0
400061a4: 13 10 00 d3 sethi %hi(0x40034c00), %o1
400061a8: 7f ff f9 b2 call 40004870 <rtems_fdisk_printf>
400061ac: 92 12 60 a8 or %o1, 0xa8, %o1 ! 40034ca8 <__FUNCTION__.6193+0xbe0>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
400061b0: d4 06 e0 70 ld [ %i3 + 0x70 ], %o2
400061b4: 90 10 00 1b mov %i3, %o0
400061b8: 13 10 00 d3 sethi %hi(0x40034c00), %o1
400061bc: 7f ff f9 ad call 40004870 <rtems_fdisk_printf>
400061c0: 92 12 60 c0 or %o1, 0xc0, %o1 ! 40034cc0 <__FUNCTION__.6193+0xbf8>
* 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;
400061c4: c2 06 e0 34 ld [ %i3 + 0x34 ], %g1
uint32_t count = 0;
while (sc)
400061c8: 80 a0 60 00 cmp %g1, 0
400061cc: 22 80 00 07 be,a 400061e8 <rtems_fdisk_ioctl+0x594> <== NEVER TAKEN
400061d0: d6 06 e0 3c ld [ %i3 + 0x3c ], %o3 <== NOT EXECUTED
{
count++;
sc = sc->next;
400061d4: 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)
400061d8: 80 a0 60 00 cmp %g1, 0
400061dc: 12 bf ff fe bne 400061d4 <rtems_fdisk_ioctl+0x580> <== NEVER TAKEN
400061e0: 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)",
400061e4: d6 06 e0 3c ld [ %i3 + 0x3c ], %o3
400061e8: 94 10 00 1d mov %i5, %o2
400061ec: 90 10 00 1b mov %i3, %o0
400061f0: 13 10 00 d3 sethi %hi(0x40034c00), %o1
400061f4: 7f ff f9 9f call 40004870 <rtems_fdisk_printf>
400061f8: 92 12 60 d0 or %o1, 0xd0, %o1 ! 40034cd0 <__FUNCTION__.6193+0xc08>
* 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;
400061fc: c2 06 e0 40 ld [ %i3 + 0x40 ], %g1
uint32_t count = 0;
while (sc)
40006200: 80 a0 60 00 cmp %g1, 0
40006204: 02 80 00 06 be 4000621c <rtems_fdisk_ioctl+0x5c8> <== NEVER TAKEN
40006208: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
4000620c: 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)
40006210: 80 a0 60 00 cmp %g1, 0
40006214: 12 bf ff fe bne 4000620c <rtems_fdisk_ioctl+0x5b8>
40006218: 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)",
4000621c: 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;
40006220: ba 02 80 1d add %o2, %i5, %i5
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
40006224: 90 10 00 1b mov %i3, %o0
40006228: 13 10 00 d3 sethi %hi(0x40034c00), %o1
4000622c: 7f ff f9 91 call 40004870 <rtems_fdisk_printf>
40006230: 92 12 60 f0 or %o1, 0xf0, %o1 ! 40034cf0 <__FUNCTION__.6193+0xc28>
* 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;
40006234: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
uint32_t count = 0;
while (sc)
40006238: 80 a0 60 00 cmp %g1, 0
4000623c: 02 80 00 06 be 40006254 <rtems_fdisk_ioctl+0x600> <== ALWAYS TAKEN
40006240: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
40006244: 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)
40006248: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000624c: 12 bf ff fe bne 40006244 <rtems_fdisk_ioctl+0x5f0> <== NOT EXECUTED
40006250: 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)",
40006254: 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;
40006258: ba 07 40 0a add %i5, %o2, %i5
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
4000625c: 90 10 00 1b mov %i3, %o0
40006260: 13 10 00 d3 sethi %hi(0x40034c00), %o1
40006264: 7f ff f9 83 call 40004870 <rtems_fdisk_printf>
40006268: 92 12 61 08 or %o1, 0x108, %o1 ! 40034d08 <__FUNCTION__.6193+0xc40>
* 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;
4000626c: c4 06 e0 58 ld [ %i3 + 0x58 ], %g2
uint32_t count = 0;
while (sc)
40006270: 80 a0 a0 00 cmp %g2, 0
40006274: 02 80 00 06 be 4000628c <rtems_fdisk_ioctl+0x638> <== ALWAYS TAKEN
40006278: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
4000627c: 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)
40006280: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006284: 12 bf ff fe bne 4000627c <rtems_fdisk_ioctl+0x628> <== NOT EXECUTED
40006288: 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)",
4000628c: 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;
40006290: ba 07 40 0a add %i5, %o2, %i5
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
40006294: 90 10 00 1b mov %i3, %o0
40006298: 13 10 00 d3 sethi %hi(0x40034c00), %o1
4000629c: 7f ff f9 75 call 40004870 <rtems_fdisk_printf>
400062a0: 92 12 61 20 or %o1, 0x120, %o1 ! 40034d20 <__FUNCTION__.6193+0xc58>
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
400062a4: c4 06 e0 30 ld [ %i3 + 0x30 ], %g2
400062a8: 80 a0 a0 00 cmp %g2, 0
400062ac: 02 80 00 db be 40006618 <rtems_fdisk_ioctl+0x9c4> <== NEVER TAKEN
400062b0: 87 28 a0 02 sll %g2, 2, %g3
400062b4: 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;
400062b8: 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)
400062bc: 85 28 a0 04 sll %g2, 4, %g2
400062c0: 84 20 80 03 sub %g2, %g3, %g2
400062c4: 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;
400062c8: c6 00 60 04 ld [ %g1 + 4 ], %g3
400062cc: 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++)
400062d0: 80 a0 40 02 cmp %g1, %g2
400062d4: 12 bf ff fd bne 400062c8 <rtems_fdisk_ioctl+0x674> <== NEVER TAKEN
400062d8: 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,
400062dc: 19 10 00 d2 sethi %hi(0x40034800), %o4
400062e0: 80 a7 40 0b cmp %i5, %o3
400062e4: 02 80 02 71 be 40006ca8 <rtems_fdisk_ioctl+0x1054> <== ALWAYS TAKEN
400062e8: 98 13 20 20 or %o4, 0x20, %o4
400062ec: 94 10 00 1d mov %i5, %o2
400062f0: 90 10 00 1b mov %i3, %o0
400062f4: 13 10 00 d3 sethi %hi(0x40034c00), %o1
400062f8: 7f ff f9 5e call 40004870 <rtems_fdisk_printf>
400062fc: 92 12 61 38 or %o1, 0x138, %o1 ! 40034d38 <__FUNCTION__.6193+0xc70>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
40006300: d4 06 e0 30 ld [ %i3 + 0x30 ], %o2
40006304: 90 10 00 1b mov %i3, %o0
40006308: 13 10 00 d3 sethi %hi(0x40034c00), %o1
4000630c: 7f ff f9 59 call 40004870 <rtems_fdisk_printf>
40006310: 92 12 61 58 or %o1, 0x158, %o1 ! 40034d58 <__FUNCTION__.6193+0xc90>
for (device = 0; device < fd->device_count; device++)
40006314: c2 06 e0 30 ld [ %i3 + 0x30 ], %g1
40006318: 80 a0 60 00 cmp %g1, 0
4000631c: 22 80 00 8e be,a 40006554 <rtems_fdisk_ioctl+0x900> <== NEVER TAKEN
40006320: fa 06 e0 40 ld [ %i3 + 0x40 ], %i5 <== NOT EXECUTED
40006324: b0 10 20 00 clr %i0
40006328: c0 27 bf ec clr [ %fp + -20 ]
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
4000632c: d4 07 bf ec ld [ %fp + -20 ], %o2
40006330: 13 10 00 d3 sethi %hi(0x40034c00), %o1
40006334: 90 10 00 1b mov %i3, %o0
40006338: 7f ff f9 4e call 40004870 <rtems_fdisk_printf>
4000633c: 92 12 61 68 or %o1, 0x168, %o1
rtems_fdisk_printf (fd, " Segment count\t%ld",
40006340: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
40006344: 90 10 00 1b mov %i3, %o0
40006348: 82 00 40 18 add %g1, %i0, %g1
4000634c: d4 00 60 04 ld [ %g1 + 4 ], %o2
40006350: 13 10 00 d3 sethi %hi(0x40034c00), %o1
40006354: 7f ff f9 47 call 40004870 <rtems_fdisk_printf>
40006358: 92 12 61 78 or %o1, 0x178, %o1 ! 40034d78 <__FUNCTION__.6193+0xcb0>
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
4000635c: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
40006360: 82 00 40 18 add %g1, %i0, %g1
40006364: c4 00 60 04 ld [ %g1 + 4 ], %g2
40006368: 80 a0 a0 00 cmp %g2, 0
4000636c: 02 80 00 73 be 40006538 <rtems_fdisk_ioctl+0x8e4> <== NEVER TAKEN
40006370: c4 07 bf ec ld [ %fp + -20 ], %g2
40006374: b2 10 20 00 clr %i1
40006378: b4 10 20 00 clr %i2
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
4000637c: 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);
40006380: 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];
40006384: 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);
40006388: 94 07 bf f8 add %fp, -8, %o2
4000638c: 7f ff f8 b9 call 40004670 <rtems_fdisk_queue_status>
40006390: 92 10 00 1c mov %i4, %o1
for (page = 0; page < sc->pages; page++)
40006394: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
40006398: 80 a3 20 00 cmp %o4, 0
4000639c: 22 80 00 94 be,a 400065ec <rtems_fdisk_ioctl+0x998> <== NEVER TAKEN
400063a0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
400063a4: 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;
400063a8: a8 10 20 00 clr %l4
400063ac: 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;
400063b0: ae 10 20 00 clr %l7
uint32_t used = 0;
400063b4: 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;
400063b8: 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++)
400063bc: a4 10 20 00 clr %l2
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
400063c0: 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)
400063c4: 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;
400063c8: fa 01 00 02 ld [ %g4 + %g2 ], %i5
400063cc: 80 a7 7f ff cmp %i5, -1
400063d0: 02 80 00 7d be 400065c4 <rtems_fdisk_ioctl+0x970>
400063d4: 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;
400063d8: 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],
400063dc: 80 88 a0 01 btst 1, %g2
400063e0: 12 80 00 07 bne 400063fc <rtems_fdisk_ioctl+0x7a8> <== NEVER TAKEN
400063e4: 80 a0 e0 00 cmp %g3, 0
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
400063e8: 80 88 a0 02 btst 2, %g2
400063ec: 32 80 00 7c bne,a 400065dc <rtems_fdisk_ioctl+0x988>
400063f0: ae 05 e0 01 inc %l7
RTEMS_FDISK_PAGE_USED))
used++;
400063f4: ac 05 a0 01 inc %l6
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
400063f8: 80 a0 e0 00 cmp %g3, 0
400063fc: 22 80 00 23 be,a 40006488 <rtems_fdisk_ioctl+0x834> <== NEVER TAKEN
40006400: a4 04 a0 01 inc %l2 <== NOT EXECUTED
40006404: ba 10 20 00 clr %i5
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
40006408: 10 80 00 06 b 40006420 <rtems_fdisk_ioctl+0x7cc>
4000640c: a6 0d 20 ff and %l4, 0xff, %l3
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
40006410: ba 07 60 01 inc %i5
40006414: 80 a7 40 03 cmp %i5, %g3
40006418: 1a 80 00 1a bcc 40006480 <rtems_fdisk_ioctl+0x82c>
4000641c: 82 10 00 03 mov %g3, %g1
{
if ((fd->blocks[block].segment == sc) &&
40006420: 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)
40006424: 83 2f 60 03 sll %i5, 3, %g1
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
40006428: c8 00 80 01 ld [ %g2 + %g1 ], %g4
4000642c: 80 a7 00 04 cmp %i4, %g4
40006430: 12 bf ff f8 bne 40006410 <rtems_fdisk_ioctl+0x7bc>
40006434: 82 00 80 01 add %g2, %g1, %g1
40006438: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000643c: 80 a4 80 01 cmp %l2, %g1
40006440: 32 bf ff f5 bne,a 40006414 <rtems_fdisk_ioctl+0x7c0>
40006444: ba 07 60 01 inc %i5
(fd->blocks[block].page == page) && !is_active)
40006448: 80 a4 e0 00 cmp %l3, 0
4000644c: 32 bf ff f2 bne,a 40006414 <rtems_fdisk_ioctl+0x7c0> <== ALWAYS TAKEN
40006450: ba 07 60 01 inc %i5
rtems_fdisk_printf (fd,
40006454: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
40006458: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000645c: 13 10 00 d3 sethi %hi(0x40034c00), %o1 <== NOT EXECUTED
40006460: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
40006464: 7f ff f9 03 call 40004870 <rtems_fdisk_printf> <== NOT EXECUTED
40006468: 92 12 61 90 or %o1, 0x190, %o1 <== NOT EXECUTED
4000646c: c6 06 e0 1c ld [ %i3 + 0x1c ], %g3 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
40006470: ba 07 60 01 inc %i5 <== NOT EXECUTED
40006474: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
40006478: 0a bf ff ea bcs 40006420 <rtems_fdisk_ioctl+0x7cc> <== NOT EXECUTED
4000647c: 82 10 00 03 mov %g3, %g1 <== NOT EXECUTED
40006480: 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++)
40006484: a4 04 a0 01 inc %l2
40006488: 80 a4 80 0c cmp %l2, %o4
4000648c: 2a bf ff ce bcs,a 400063c4 <rtems_fdisk_ioctl+0x770>
40006490: c8 07 20 10 ld [ %i4 + 0x10 ], %g4
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
40006494: 80 a0 60 00 cmp %g1, 0
40006498: 02 80 00 53 be 400065e4 <rtems_fdisk_ioctl+0x990> <== NEVER TAKEN
4000649c: 83 28 60 03 sll %g1, 3, %g1
400064a0: 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)
400064a4: 84 10 20 00 clr %g2
400064a8: 86 10 20 00 clr %g3
}
count = 0;
for (block = 0; block < fd->block_count; block++)
{
if (fd->blocks[block].segment == sc)
400064ac: c8 07 40 02 ld [ %i5 + %g2 ], %g4
400064b0: 84 00 a0 08 add %g2, 8, %g2
count++;
400064b4: 88 1f 00 04 xor %i4, %g4, %g4
400064b8: 80 a0 00 04 cmp %g0, %g4
400064bc: 86 60 ff ff subx %g3, -1, %g3
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400064c0: 80 a0 80 01 cmp %g2, %g1
400064c4: 32 bf ff fb bne,a 400064b0 <rtems_fdisk_ioctl+0x85c>
400064c8: 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),
400064cc: 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 +
400064d0: 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" \
400064d4: c4 23 a0 60 st %g2, [ %sp + 0x60 ]
400064d8: ee 23 a0 5c st %l7, [ %sp + 0x5c ]
400064dc: ec 23 a0 64 st %l6, [ %sp + 0x64 ]
400064e0: 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)
400064e4: 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" \
400064e8: 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)
400064ec: 84 00 80 04 add %g2, %g4, %g2
400064f0: 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" \
400064f4: 84 23 00 02 sub %o4, %g2, %g2
400064f8: 9a 10 00 01 mov %g1, %o5
400064fc: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
40006500: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
40006504: 90 10 00 1b mov %i3, %o0
40006508: 13 10 00 d3 sethi %hi(0x40034c00), %o1
4000650c: 96 07 bf f8 add %fp, -8, %o3
40006510: 7f ff f8 d8 call 40004870 <rtems_fdisk_printf>
40006514: 92 12 61 c0 or %o1, 0x1c0, %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++)
40006518: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
4000651c: b4 06 a0 01 inc %i2
40006520: 82 00 40 18 add %g1, %i0, %g1
40006524: c4 00 60 04 ld [ %g1 + 4 ], %g2
40006528: 80 a6 80 02 cmp %i2, %g2
4000652c: 0a bf ff 94 bcs 4000637c <rtems_fdisk_ioctl+0x728>
40006530: 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++)
40006534: c4 07 bf ec ld [ %fp + -20 ], %g2
40006538: c2 06 e0 30 ld [ %i3 + 0x30 ], %g1
4000653c: 84 00 a0 01 inc %g2
40006540: c4 27 bf ec st %g2, [ %fp + -20 ]
40006544: 80 a0 80 01 cmp %g2, %g1
40006548: 0a bf ff 79 bcs 4000632c <rtems_fdisk_ioctl+0x6d8> <== NEVER TAKEN
4000654c: b0 06 20 0c add %i0, 0xc, %i0
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
40006550: fa 06 e0 40 ld [ %i3 + 0x40 ], %i5
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
40006554: 90 10 00 1b mov %i3, %o0
40006558: 13 10 00 d3 sethi %hi(0x40034c00), %o1
4000655c: 7f ff f8 c5 call 40004870 <rtems_fdisk_printf>
40006560: 92 12 62 00 or %o1, 0x200, %o1 ! 40034e00 <__FUNCTION__.6193+0xd38>
while (sc)
40006564: 80 a7 60 00 cmp %i5, 0
40006568: 02 80 00 11 be 400065ac <rtems_fdisk_ioctl+0x958> <== NEVER TAKEN
4000656c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40006570: 35 10 00 d3 sethi %hi(0x40034c00), %i2
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
40006574: b8 10 20 00 clr %i4
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40006578: b4 16 a2 10 or %i2, 0x210, %i2
4000657c: d6 07 60 08 ld [ %i5 + 8 ], %o3
40006580: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40006584: da 07 60 20 ld [ %i5 + 0x20 ], %o5
40006588: 94 10 00 1c mov %i4, %o2
4000658c: 90 10 00 1b mov %i3, %o0
40006590: 7f ff f8 b8 call 40004870 <rtems_fdisk_printf>
40006594: 92 10 00 1a mov %i2, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
40006598: 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)
4000659c: 80 a7 60 00 cmp %i5, 0
400065a0: 12 bf ff f7 bne 4000657c <rtems_fdisk_ioctl+0x928>
400065a4: b8 07 20 01 inc %i4
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
400065a8: c2 07 bf e4 ld [ %fp + -28 ], %g1
400065ac: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2
400065b0: 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]);
400065b4: c2 07 bf e8 ld [ %fp + -24 ], %g1
400065b8: 84 00 80 15 add %g2, %l5, %g2
break;
400065bc: 10 bf fe 8b b 40005fe8 <rtems_fdisk_ioctl+0x394>
400065c0: 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;
400065c4: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400065c8: 80 a1 3f ff cmp %g4, -1
400065cc: 32 bf ff 84 bne,a 400063dc <rtems_fdisk_ioctl+0x788> <== NEVER TAKEN
400065d0: 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++;
400065d4: 10 bf ff 89 b 400063f8 <rtems_fdisk_ioctl+0x7a4>
400065d8: a2 04 60 01 inc %l1
RTEMS_FDISK_PAGE_USED))
used++;
else
{
active++;
is_active = true;
400065dc: 10 bf ff 87 b 400063f8 <rtems_fdisk_ioctl+0x7a4>
400065e0: a8 10 20 01 mov 1, %l4
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400065e4: 10 bf ff ba b 400064cc <rtems_fdisk_ioctl+0x878> <== NOT EXECUTED
400065e8: 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;
400065ec: ae 10 20 00 clr %l7 <== NOT EXECUTED
uint32_t used = 0;
400065f0: 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;
400065f4: 10 bf ff a8 b 40006494 <rtems_fdisk_ioctl+0x840> <== NOT EXECUTED
400065f8: 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;
400065fc: 40 00 70 cf call 40022938 <__errno> <== NOT EXECUTED
40006600: 01 00 00 00 nop <== NOT EXECUTED
40006604: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
40006608: 82 10 20 13 mov 0x13, %g1 <== NOT EXECUTED
4000660c: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
40006610: 10 bf fe 76 b 40005fe8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
40006614: 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;
40006618: 10 bf ff 31 b 400062dc <rtems_fdisk_ioctl+0x688> <== NOT EXECUTED
4000661c: 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);
40006620: 40 00 70 c6 call 40022938 <__errno>
40006624: a8 06 a0 28 add %i2, 0x28, %l4
40006628: fa 04 20 d8 ld [ %l0 + 0xd8 ], %i5
4000662c: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
40006630: d0 27 bf e0 st %o0, [ %fp + -32 ]
40006634: 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)
40006638: ac 10 20 01 mov 1, %l6
4000663c: f4 27 bf ec st %i2, [ %fp + -20 ]
40006640: 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++)
40006644: 82 05 bf ff add %l6, -1, %g1
40006648: 80 a0 40 1c cmp %g1, %i4
4000664c: 3a 80 02 7d bcc,a 40007040 <rtems_fdisk_ioctl+0x13ec>
40006650: f4 07 bf ec ld [ %fp + -20 ], %i2
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40006654: d0 05 3f f4 ld [ %l4 + -12 ], %o0
40006658: 7f ff f0 12 call 400026a0 <.udiv>
4000665c: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
40006660: d0 27 bf e4 st %o0, [ %fp + -28 ]
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40006664: 80 a2 20 00 cmp %o0, 0
40006668: 02 80 01 0e be 40006aa0 <rtems_fdisk_ioctl+0xe4c> <== NEVER TAKEN
4000666c: f4 05 3f f8 ld [ %l4 + -8 ], %i2
40006670: b2 10 20 00 clr %i1
40006674: ec 27 bf dc st %l6, [ %fp + -36 ]
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
40006678: 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);
4000667c: 05 10 00 d2 sethi %hi(0x40034800), %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);
40006680: 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);
40006684: 92 10 a1 a8 or %g2, 0x1a8, %o1
40006688: 90 10 00 1d mov %i5, %o0
4000668c: 7f ff f8 57 call 400047e8 <rtems_fdisk_info>
40006690: 94 10 00 17 mov %l7, %o2
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40006694: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
40006698: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000669c: 82 20 80 01 sub %g2, %g1, %g1
400066a0: 80 a5 c0 01 cmp %l7, %g1
400066a4: 1a 80 01 02 bcc 40006aac <rtems_fdisk_ioctl+0xe58> <== NEVER TAKEN
400066a8: 11 10 00 d2 sethi %hi(0x40034800), %o0
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
400066ac: e6 07 60 18 ld [ %i5 + 0x18 ], %l3
400066b0: a5 2d e0 03 sll %l7, 3, %l2
/*
* Does the page exist in flash ?
*/
if (bc->segment)
400066b4: f8 04 c0 12 ld [ %l3 + %l2 ], %i4
400066b8: 80 a7 20 00 cmp %i4, 0
400066bc: 02 80 00 6d be 40006870 <rtems_fdisk_ioctl+0xc1c>
400066c0: a2 04 c0 12 add %l3, %l2, %l1
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
400066c4: c2 04 60 04 ld [ %l1 + 4 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400066c8: d4 07 20 08 ld [ %i4 + 8 ], %o2
400066cc: 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];
400066d0: f0 07 20 10 ld [ %i4 + 0x10 ], %i0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400066d4: 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];
400066d8: 83 28 60 03 sll %g1, 3, %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400066dc: 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];
400066e0: b0 06 00 01 add %i0, %g1, %i0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400066e4: 13 10 00 d2 sethi %hi(0x40034800), %o1
400066e8: 7f ff f8 40 call 400047e8 <rtems_fdisk_info>
400066ec: 92 12 61 e0 or %o1, 0x1e0, %o1 ! 400349e0 <__FUNCTION__.6193+0x918>
#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,
400066f0: 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);
400066f4: 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,
400066f8: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
400066fc: 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,
40006700: 92 10 00 16 mov %l6, %o1
40006704: 7f ff ef ad call 400025b8 <.umul>
40006708: 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;
4000670c: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
40006710: b7 2d 60 04 sll %l5, 4, %i3
40006714: 87 2d 60 02 sll %l5, 2, %g3
40006718: 86 26 c0 03 sub %i3, %g3, %g3
4000671c: b6 01 00 03 add %g4, %g3, %i3
40006720: 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;
40006724: 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,
40006728: 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;
4000672c: 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;
40006730: 93 2e e0 06 sll %i3, 6, %o1
40006734: 89 2e e0 04 sll %i3, 4, %g4
40006738: 88 22 40 04 sub %o1, %g4, %g4
4000673c: 88 03 c0 04 add %o7, %g4, %g4
40006740: 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,
40006744: 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",
40006748: 98 10 00 08 mov %o0, %o4
4000674c: c4 3f bf d0 std %g2, [ %fp + -48 ]
40006750: 94 10 00 15 mov %l5, %o2
40006754: 96 10 00 1b mov %i3, %o3
40006758: 9a 10 00 16 mov %l6, %o5
4000675c: c8 27 bf cc st %g4, [ %fp + -52 ]
40006760: 90 10 00 1d mov %i5, %o0
40006764: 13 10 00 d2 sethi %hi(0x40034800), %o1
40006768: 7f ff f8 42 call 40004870 <rtems_fdisk_printf>
4000676c: 92 12 62 08 or %o1, 0x208, %o1 ! 40034a08 <__FUNCTION__.6193+0x940>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
40006770: c6 07 bf d4 ld [ %fp + -44 ], %g3
40006774: c8 07 bf cc ld [ %fp + -52 ], %g4
40006778: c4 07 bf d0 ld [ %fp + -48 ], %g2
4000677c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
40006780: 90 10 00 04 mov %g4, %o0
40006784: 92 10 00 15 mov %l5, %o1
40006788: 94 10 00 1b mov %i3, %o2
4000678c: 96 10 00 02 mov %g2, %o3
40006790: 98 10 00 1a mov %i2, %o4
40006794: 9f c0 c0 00 call %g3
40006798: 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,
4000679c: 80 a2 20 00 cmp %o0, 0
400067a0: 22 80 00 f9 be,a 40006b84 <rtems_fdisk_ioctl+0xf30>
400067a4: 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;
400067a8: 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);
400067ac: 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))
400067b0: 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;
400067b4: 86 08 ff fd and %g3, -3, %g3
400067b8: 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)) +
400067bc: 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))
400067c0: 80 88 a0 08 btst 8, %g2
400067c4: 02 80 00 d6 be 40006b1c <rtems_fdisk_ioctl+0xec8> <== NEVER TAKEN
400067c8: aa 05 60 02 add %l5, 2, %l5
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
400067cc: c2 27 bf d8 st %g1, [ %fp + -40 ]
400067d0: 90 10 00 1d mov %i5, %o0
400067d4: 92 10 00 1c mov %i4, %o1
400067d8: 94 10 00 15 mov %l5, %o2
400067dc: 96 07 bf f6 add %fp, -10, %o3
400067e0: 7f ff f8 46 call 400048f8 <rtems_fdisk_seg_read>
400067e4: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
400067e8: b6 92 20 00 orcc %o0, 0, %i3
400067ec: 12 80 00 d5 bne 40006b40 <rtems_fdisk_ioctl+0xeec> <== NEVER TAKEN
400067f0: c2 07 bf d8 ld [ %fp + -40 ], %g1
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
400067f4: c8 16 20 02 lduh [ %i0 + 2 ], %g4
400067f8: c4 17 bf f6 lduh [ %fp + -10 ], %g2
400067fc: 87 29 20 10 sll %g4, 0x10, %g3
40006800: 88 08 80 04 and %g2, %g4, %g4
40006804: 89 29 20 10 sll %g4, 0x10, %g4
40006808: 80 a1 00 03 cmp %g4, %g3
4000680c: 02 80 00 c4 be 40006b1c <rtems_fdisk_ioctl+0xec8> <== ALWAYS TAKEN
40006810: 9b 30 e0 10 srl %g3, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
40006814: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
40006818: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
4000681c: 99 28 a0 10 sll %g2, 0x10, %o4 <== NOT EXECUTED
40006820: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40006824: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED
40006828: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
4000682c: 7f ff f8 eb call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006830: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40006834: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 <== NOT EXECUTED
sc->pages_used++;
40006838: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
4000683c: 84 00 bf ff add %g2, -1, %g2
sc->pages_used++;
40006840: 82 00 60 01 inc %g1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40006844: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
sc->pages_used++;
40006848: 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);
4000684c: 90 10 00 1d mov %i5, %o0
40006850: 7f ff f9 8a call 40004e78 <rtems_fdisk_queue_segment>
40006854: 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)
40006858: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000685c: 80 88 60 02 btst 2, %g1
40006860: 32 80 00 05 bne,a 40006874 <rtems_fdisk_ioctl+0xc20> <== NEVER TAKEN
40006864: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
rtems_fdisk_compact (fd);
40006868: 7f ff fb 50 call 400055a8 <rtems_fdisk_compact>
4000686c: 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;
40006870: f8 07 60 34 ld [ %i5 + 0x34 ], %i4
uint32_t count = 0;
while (sc)
40006874: 80 a7 20 00 cmp %i4, 0
40006878: 02 80 00 e7 be 40006c14 <rtems_fdisk_ioctl+0xfc0> <== NEVER TAKEN
4000687c: 82 10 00 1c mov %i4, %g1
40006880: 84 10 20 00 clr %g2
{
count++;
sc = sc->next;
40006884: 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)
40006888: 80 a0 60 00 cmp %g1, 0
4000688c: 12 bf ff fe bne 40006884 <rtems_fdisk_ioctl+0xc30>
40006890: 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) <=
40006894: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40006898: 80 a0 40 02 cmp %g1, %g2
4000689c: 1a 80 00 de bcc 40006c14 <rtems_fdisk_ioctl+0xfc0>
400068a0: 01 00 00 00 nop
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400068a4: c2 07 00 00 ld [ %i4 ], %g1
if (!queue->head)
400068a8: 80 a0 60 00 cmp %g1, 0
400068ac: 02 80 00 d8 be 40006c0c <rtems_fdisk_ioctl+0xfb8>
400068b0: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
queue->tail = 0;
queue->count--;
400068b4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
400068b8: 82 00 7f ff add %g1, -1, %g1
400068bc: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
400068c0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
400068c4: 80 a0 60 02 cmp %g1, 2
400068c8: 18 80 00 b8 bgu 40006ba8 <rtems_fdisk_ioctl+0xf54> <== NEVER TAKEN
400068cc: 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++)
400068d0: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
400068d4: 80 a0 e0 00 cmp %g3, 0
400068d8: 02 80 00 83 be 40006ae4 <rtems_fdisk_ioctl+0xe90> <== NEVER TAKEN
400068dc: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
400068e0: 10 80 00 05 b 400068f4 <rtems_fdisk_ioctl+0xca0>
400068e4: b0 10 20 00 clr %i0
400068e8: 80 a6 00 03 cmp %i0, %g3
400068ec: 02 80 00 7e be 40006ae4 <rtems_fdisk_ioctl+0xe90> <== NEVER TAKEN
400068f0: 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;
400068f4: c2 06 c0 00 ld [ %i3 ], %g1
400068f8: 80 a0 7f ff cmp %g1, -1
400068fc: 32 bf ff fb bne,a 400068e8 <rtems_fdisk_ioctl+0xc94>
40006900: b0 06 20 01 inc %i0
40006904: c2 06 e0 04 ld [ %i3 + 4 ], %g1
40006908: 80 a0 7f ff cmp %g1, -1
4000690c: 32 bf ff f7 bne,a 400068e8 <rtems_fdisk_ioctl+0xc94> <== NEVER TAKEN
40006910: 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);
40006914: 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++)
40006918: 80 a3 e0 00 cmp %o7, 0
4000691c: 02 80 00 e0 be 40006c9c <rtems_fdisk_ioctl+0x1048> <== NEVER TAKEN
40006920: 15 10 00 d3 sethi %hi(0x40034c00), %o2
40006924: 03 10 01 26 sethi %hi(0x40049800), %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)
40006928: 9e 06 80 0f add %i2, %o7, %o7
4000692c: da 00 60 e0 ld [ %g1 + 0xe0 ], %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;
40006930: 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)
40006934: 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);
40006938: c8 08 40 00 ldub [ %g1 ], %g4
4000693c: 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++)
40006940: 82 00 60 01 inc %g1
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40006944: 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++)
40006948: 80 a0 40 0f cmp %g1, %o7
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
4000694c: 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++)
40006950: 12 bf ff fa bne 40006938 <rtems_fdisk_ioctl+0xce4>
40006954: c4 13 40 02 lduh [ %o5 + %g2 ], %g2
40006958: 83 28 a0 10 sll %g2, 0x10, %g1
4000695c: 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;
40006960: 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);
40006964: c4 36 c0 00 sth %g2, [ %i3 ]
pd->block = block;
40006968: ee 26 e0 04 st %l7, [ %i3 + 4 ]
bc->segment = sc;
4000696c: 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: " \
40006970: 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;
40006974: 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;
40006978: 88 09 3f fe and %g4, -2, %g4
4000697c: 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: " \
40006980: d6 07 20 08 ld [ %i4 + 8 ], %o3
40006984: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40006988: e4 07 20 1c ld [ %i4 + 0x1c ], %l2
4000698c: d0 07 20 20 ld [ %i4 + 0x20 ], %o0
40006990: 80 a0 a0 00 cmp %g2, 0
40006994: 02 80 00 bf be 40006c90 <rtems_fdisk_ioctl+0x103c> <== ALWAYS TAKEN
40006998: de 07 20 24 ld [ %i4 + 0x24 ], %o7
4000699c: 05 10 00 d1 sethi %hi(0x40034400), %g2 <== NOT EXECUTED
400069a0: 84 10 a0 08 or %g2, 8, %g2 ! 40034408 <__FUNCTION__.6193+0x340><== NOT EXECUTED
400069a4: 89 29 20 10 sll %g4, 0x10, %g4
400069a8: 89 31 20 10 srl %g4, 0x10, %g4
400069ac: 94 10 00 17 mov %l7, %o2
400069b0: 9a 10 00 18 mov %i0, %o5
400069b4: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
400069b8: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
400069bc: d0 23 a0 64 st %o0, [ %sp + 0x64 ]
400069c0: de 23 a0 68 st %o7, [ %sp + 0x68 ]
400069c4: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
400069c8: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
400069cc: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
400069d0: 13 10 00 d2 sethi %hi(0x40034800), %o1
400069d4: ee 23 a0 78 st %l7, [ %sp + 0x78 ]
400069d8: 92 12 63 18 or %o1, 0x318, %o1
400069dc: 7f ff f7 83 call 400047e8 <rtems_fdisk_info>
400069e0: 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);
400069e4: d4 07 20 18 ld [ %i4 + 0x18 ], %o2
400069e8: 90 10 00 1d mov %i5, %o0
400069ec: 92 10 00 1c mov %i4, %o1
400069f0: 94 06 00 0a add %i0, %o2, %o2
400069f4: 7f ff f8 3b call 40004ae0 <rtems_fdisk_seg_write_page>
400069f8: 96 10 00 1a mov %i2, %o3
if (ret)
400069fc: a4 92 20 00 orcc %o0, 0, %l2
40006a00: 22 80 00 78 be,a 40006be0 <rtems_fdisk_ioctl+0xf8c> <== ALWAYS TAKEN
40006a04: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
40006a08: e2 07 20 08 ld [ %i4 + 8 ], %l1 <== NOT EXECUTED
40006a0c: 40 00 79 a6 call 400250a4 <strerror> <== NOT EXECUTED
40006a10: f6 07 20 0c ld [ %i4 + 0xc ], %i3 <== NOT EXECUTED
40006a14: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
40006a18: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006a1c: e4 23 a0 5c st %l2, [ %sp + 0x5c ] <== NOT EXECUTED
40006a20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006a24: 92 12 63 68 or %o1, 0x368, %o1 <== NOT EXECUTED
40006a28: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40006a2c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40006a30: 7f ff f7 6e call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
40006a34: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
40006a38: 90 10 00 1d mov %i5, %o0
40006a3c: 7f ff f9 0f call 40004e78 <rtems_fdisk_queue_segment>
40006a40: 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)
40006a44: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
40006a48: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40006a4c: 80 a0 80 01 cmp %g2, %g1
40006a50: 1a 80 00 08 bcc 40006a70 <rtems_fdisk_ioctl+0xe1c>
40006a54: 80 a4 a0 00 cmp %l2, 0
fd->starvations++;
40006a58: 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);
40006a5c: 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++;
40006a60: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
40006a64: 7f ff fa d1 call 400055a8 <rtems_fdisk_compact>
40006a68: 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)
40006a6c: 80 a4 a0 00 cmp %l2, 0
40006a70: 32 80 01 72 bne,a 40007038 <rtems_fdisk_ioctl+0x13e4> <== NEVER TAKEN
40006a74: 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)
40006a78: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40006a7c: b2 06 60 01 inc %i1
40006a80: b4 06 80 01 add %i2, %g1, %i2
40006a84: c2 07 bf e4 ld [ %fp + -28 ], %g1
40006a88: 80 a6 40 01 cmp %i1, %g1
40006a8c: 32 bf fe fc bne,a 4000667c <rtems_fdisk_ioctl+0xa28> <== NEVER TAKEN
40006a90: ee 05 3f f0 ld [ %l4 + -16 ], %l7 <== NOT EXECUTED
40006a94: c4 07 bf ec ld [ %fp + -20 ], %g2
40006a98: ec 07 bf dc ld [ %fp + -36 ], %l6
40006a9c: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
40006aa0: a8 05 20 10 add %l4, 0x10, %l4
40006aa4: 10 bf fe e8 b 40006644 <rtems_fdisk_ioctl+0x9f0>
40006aa8: ac 05 a0 01 inc %l6
40006aac: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40006ab0: 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);
40006ab4: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
40006ab8: 7f ff f8 48 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006abc: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006ac0: 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);
40006ac4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40006ac8: 9f c0 40 00 call %g1
40006acc: 90 10 00 1a mov %i2, %o0
40006ad0: c4 04 20 d8 ld [ %l0 + 0xd8 ], %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);
40006ad4: c2 07 bf e0 ld [ %fp + -32 ], %g1
40006ad8: 84 00 80 15 add %g2, %l5, %g2
break;
40006adc: 10 bf fd 43 b 40005fe8 <rtems_fdisk_ioctl+0x394>
40006ae0: c0 20 40 00 clr [ %g1 ]
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
40006ae4: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
40006ae8: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
40006aec: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40006af0: ea 07 bf e8 ld [ %fp + -24 ], %l5 <== NOT EXECUTED
40006af4: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40006af8: 7f ff f8 38 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006afc: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 40034be0 <__FUNCTION__.6193+0xb18><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
40006b00: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
40006b04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006b08: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40006b0c: 7f ff f8 db call 40004e78 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40006b10: c2 27 20 28 st %g1, [ %i4 + 0x28 ] <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006b14: 10 bf ff ec b 40006ac4 <rtems_fdisk_ioctl+0xe70> <== NOT EXECUTED
40006b18: 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,
40006b1c: 90 10 00 1d mov %i5, %o0
40006b20: 92 10 00 1c mov %i4, %o1
40006b24: 94 10 00 15 mov %l5, %o2
40006b28: 96 06 20 02 add %i0, 2, %o3
40006b2c: 7f ff f7 b6 call 40004a04 <rtems_fdisk_seg_write>
40006b30: 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)
40006b34: b6 92 20 00 orcc %o0, 0, %i3
40006b38: 22 bf ff 40 be,a 40006838 <rtems_fdisk_ioctl+0xbe4> <== ALWAYS TAKEN
40006b3c: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
40006b40: d4 07 20 08 ld [ %i4 + 8 ], %o2 <== NOT EXECUTED
40006b44: ea 07 20 0c ld [ %i4 + 0xc ], %l5 <== NOT EXECUTED
40006b48: f0 04 60 04 ld [ %l1 + 4 ], %i0 <== NOT EXECUTED
40006b4c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40006b50: 40 00 79 55 call 400250a4 <strerror> <== NOT EXECUTED
40006b54: d4 27 bf c8 st %o2, [ %fp + -56 ] <== NOT EXECUTED
40006b58: d4 07 bf c8 ld [ %fp + -56 ], %o2 <== NOT EXECUTED
40006b5c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006b60: f6 23 a0 5c st %i3, [ %sp + 0x5c ] <== NOT EXECUTED
40006b64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006b68: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
40006b6c: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
40006b70: 92 12 62 b0 or %o1, 0x2b0, %o1 <== NOT EXECUTED
40006b74: 7f ff f7 1d call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
40006b78: 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);
40006b7c: 10 bf ff 35 b 40006850 <rtems_fdisk_ioctl+0xbfc> <== NOT EXECUTED
40006b80: 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",
40006b84: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40006b88: da 04 60 04 ld [ %l1 + 4 ], %o5
40006b8c: 90 10 00 1d mov %i5, %o0
40006b90: 13 10 00 d2 sethi %hi(0x40034800), %o1
40006b94: 94 10 00 17 mov %l7, %o2
40006b98: 7f ff f7 14 call 400047e8 <rtems_fdisk_info>
40006b9c: 92 12 62 30 or %o1, 0x230, %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)
40006ba0: 10 bf ff b7 b 40006a7c <rtems_fdisk_ioctl+0xe28>
40006ba4: 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);
40006ba8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006bac: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40006bb0: 7f ff f6 b0 call 40004670 <rtems_fdisk_queue_status> <== NOT EXECUTED
40006bb4: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
40006bb8: d6 07 20 08 ld [ %i4 + 8 ], %o3 <== NOT EXECUTED
40006bbc: d8 07 20 0c ld [ %i4 + 0xc ], %o4 <== NOT EXECUTED
40006bc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006bc4: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
40006bc8: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
40006bcc: 92 12 62 f0 or %o1, 0x2f0, %o1 <== NOT EXECUTED
40006bd0: 7f ff f7 06 call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
40006bd4: 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++)
40006bd8: 10 bf ff 3f b 400068d4 <rtems_fdisk_ioctl+0xc80> <== NOT EXECUTED
40006bdc: 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);
40006be0: 92 10 00 1c mov %i4, %o1
40006be4: 94 10 00 18 mov %i0, %o2
40006be8: 7f ff f7 ad call 40004a9c <rtems_fdisk_seg_write_page_desc>
40006bec: 96 10 00 1b mov %i3, %o3
if (ret)
40006bf0: a4 92 20 00 orcc %o0, 0, %l2
40006bf4: 32 80 00 19 bne,a 40006c58 <rtems_fdisk_ioctl+0x1004> <== NEVER TAKEN
40006bf8: e6 07 20 08 ld [ %i4 + 8 ], %l3 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
40006bfc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40006c00: 82 00 60 01 inc %g1
40006c04: 10 bf ff 8d b 40006a38 <rtems_fdisk_ioctl+0xde4>
40006c08: 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;
40006c0c: 10 bf ff 2a b 400068b4 <rtems_fdisk_ioctl+0xc60>
40006c10: 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);
40006c14: 7f ff fa 65 call 400055a8 <rtems_fdisk_compact>
40006c18: 90 10 00 1d mov %i5, %o0
40006c1c: 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)
40006c20: 80 a7 20 00 cmp %i4, 0
40006c24: 32 bf ff 21 bne,a 400068a8 <rtems_fdisk_ioctl+0xc54> <== ALWAYS TAKEN
40006c28: 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))
40006c2c: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40006c30: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40006c34: 12 80 01 06 bne 4000704c <rtems_fdisk_ioctl+0x13f8> <== NOT EXECUTED
40006c38: 01 00 00 00 nop <== NOT EXECUTED
40006c3c: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40006c40: 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");
40006c44: 11 10 00 d3 sethi %hi(0x40034c00), %o0 <== NOT EXECUTED
40006c48: 7f ff f7 e4 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006c4c: 90 12 22 28 or %o0, 0x228, %o0 ! 40034e28 <__FUNCTION__.6193+0xd60><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006c50: 10 bf ff 9d b 40006ac4 <rtems_fdisk_ioctl+0xe70> <== NOT EXECUTED
40006c54: 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: " \
40006c58: f0 07 20 0c ld [ %i4 + 0xc ], %i0 <== NOT EXECUTED
40006c5c: 40 00 79 12 call 400250a4 <strerror> <== NOT EXECUTED
40006c60: f6 04 60 04 ld [ %l1 + 4 ], %i3 <== NOT EXECUTED
40006c64: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
40006c68: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006c6c: e4 23 a0 5c st %l2, [ %sp + 0x5c ] <== NOT EXECUTED
40006c70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006c74: 92 12 63 a0 or %o1, 0x3a0, %o1 <== NOT EXECUTED
40006c78: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
40006c7c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
40006c80: 7f ff f6 da call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
40006c84: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
40006c88: 10 bf ff 6d b 40006a3c <rtems_fdisk_ioctl+0xde8> <== NOT EXECUTED
40006c8c: 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: " \
40006c90: 05 10 00 d1 sethi %hi(0x40034400), %g2
40006c94: 10 bf ff 44 b 400069a4 <rtems_fdisk_ioctl+0xd50>
40006c98: 84 10 a0 10 or %g2, 0x10, %g2 ! 40034410 <__FUNCTION__.6193+0x348>
* 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;
40006c9c: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
40006ca0: 10 bf ff 30 b 40006960 <rtems_fdisk_ioctl+0xd0c> <== NOT EXECUTED
40006ca4: c2 02 a2 c4 ld [ %o2 + 0x2c4 ], %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,
40006ca8: 19 10 00 d2 sethi %hi(0x40034800), %o4
40006cac: 10 bf fd 90 b 400062ec <rtems_fdisk_ioctl+0x698>
40006cb0: 98 13 20 18 or %o4, 0x18, %o4 ! 40034818 <__FUNCTION__.6193+0x750>
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
40006cb4: 40 00 6f 21 call 40022938 <__errno>
40006cb8: b0 06 a0 18 add %i2, 0x18, %i0
40006cbc: f8 04 20 d8 ld [ %l0 + 0xd8 ], %i4
40006cc0: fa 06 a0 10 ld [ %i2 + 0x10 ], %i5
40006cc4: d0 27 bf e8 st %o0, [ %fp + -24 ]
40006cc8: 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++)
40006ccc: a6 10 20 00 clr %l3
40006cd0: ea 27 bf ec st %l5, [ %fp + -20 ]
40006cd4: 80 a4 c0 1d cmp %l3, %i5
40006cd8: 1a 80 00 a5 bcc 40006f6c <rtems_fdisk_ioctl+0x1318>
40006cdc: ea 07 bf ec ld [ %fp + -20 ], %l5
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40006ce0: d0 06 20 04 ld [ %i0 + 4 ], %o0
40006ce4: 7f ff ee 6f call 400026a0 <.udiv>
40006ce8: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
data = sg->buffer;
40006cec: f2 06 20 08 ld [ %i0 + 8 ], %i1
for (b = 0; b < fb; b++, data += fd->block_size)
40006cf0: 80 a2 20 00 cmp %o0, 0
40006cf4: 02 80 00 9b be 40006f60 <rtems_fdisk_ioctl+0x130c> <== NEVER TAKEN
40006cf8: a8 10 00 08 mov %o0, %l4
40006cfc: a4 10 20 00 clr %l2
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
40006d00: 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);
40006d04: 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);
40006d08: 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);
40006d0c: 13 10 00 d2 sethi %hi(0x40034800), %o1
40006d10: 94 10 00 1b mov %i3, %o2
40006d14: 7f ff f6 b5 call 400047e8 <rtems_fdisk_info>
40006d18: 92 12 60 28 or %o1, 0x28, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40006d1c: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
40006d20: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40006d24: 82 20 80 01 sub %g2, %g1, %g1
40006d28: 80 a6 c0 01 cmp %i3, %g1
40006d2c: 1a 80 00 74 bcc 40006efc <rtems_fdisk_ioctl+0x12a8> <== NEVER TAKEN
40006d30: 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];
40006d34: ea 07 20 18 ld [ %i4 + 0x18 ], %l5
if (!bc->segment)
40006d38: fa 05 40 01 ld [ %l5 + %g1 ], %i5
40006d3c: 80 a7 60 00 cmp %i5, 0
40006d40: 02 80 00 79 be 40006f24 <rtems_fdisk_ioctl+0x12d0>
40006d44: 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];
40006d48: da 05 60 04 ld [ %l5 + 4 ], %o5
40006d4c: ec 07 60 10 ld [ %i5 + 0x10 ], %l6
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40006d50: 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];
40006d54: a3 2b 60 03 sll %o5, 3, %l1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40006d58: 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];
40006d5c: ae 05 80 11 add %l6, %l1, %l7
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40006d60: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40006d64: de 07 60 14 ld [ %i5 + 0x14 ], %o7
40006d68: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
40006d6c: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
40006d70: 80 a0 60 00 cmp %g1, 0
40006d74: 02 80 00 69 be 40006f18 <rtems_fdisk_ioctl+0x12c4>
40006d78: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40006d7c: 15 10 00 d1 sethi %hi(0x40034400), %o2
40006d80: 82 12 a0 08 or %o2, 8, %g1 ! 40034408 <__FUNCTION__.6193+0x340>
40006d84: de 23 a0 5c st %o7, [ %sp + 0x5c ]
40006d88: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
40006d8c: c6 23 a0 64 st %g3, [ %sp + 0x64 ]
40006d90: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40006d94: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
40006d98: c2 15 e0 02 lduh [ %l7 + 2 ], %g1
40006d9c: 90 10 00 1c mov %i4, %o0
40006da0: c2 23 a0 70 st %g1, [ %sp + 0x70 ]
40006da4: c2 15 80 11 lduh [ %l6 + %l1 ], %g1
40006da8: 13 10 00 d2 sethi %hi(0x40034800), %o1
40006dac: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40006db0: c2 05 e0 04 ld [ %l7 + 4 ], %g1
40006db4: 92 12 60 88 or %o1, 0x88, %o1
40006db8: c2 23 a0 78 st %g1, [ %sp + 0x78 ]
40006dbc: 7f ff f6 8b call 400047e8 <rtems_fdisk_info>
40006dc0: 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;
40006dc4: 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))
40006dc8: 80 88 60 01 btst 1, %g1
40006dcc: 12 80 00 15 bne 40006e20 <rtems_fdisk_ioctl+0x11cc> <== NEVER TAKEN
40006dd0: 80 88 60 02 btst 2, %g1
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
40006dd4: 12 80 00 1e bne 40006e4c <rtems_fdisk_ioctl+0x11f8> <== ALWAYS TAKEN
40006dd8: 92 10 00 1b mov %i3, %o1
40006ddc: 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",
40006de0: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
40006de4: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
40006de8: d8 04 60 04 ld [ %l1 + 4 ], %o4 <== NOT EXECUTED
40006dec: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40006df0: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
40006df4: 7f ff f7 79 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006df8: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006dfc: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
40006e00: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40006e04: 9f c0 40 00 call %g1
40006e08: 90 10 00 1a mov %i2, %o0
40006e0c: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
40006e10: c2 07 bf e8 ld [ %fp + -24 ], %g1
40006e14: 84 00 80 15 add %g2, %l5, %g2
break;
40006e18: 10 bf fc 74 b 40005fe8 <rtems_fdisk_ioctl+0x394>
40006e1c: c0 20 40 00 clr [ %g1 ]
40006e20: 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",
40006e24: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
40006e28: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
40006e2c: d8 04 60 04 ld [ %l1 + 4 ], %o4 <== NOT EXECUTED
40006e30: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
40006e34: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006e38: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40006e3c: 7f ff f7 67 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006e40: 90 12 21 78 or %o0, 0x178, %o0 ! 40034978 <__FUNCTION__.6193+0x8b0><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006e44: 10 bf ff ef b 40006e00 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
40006e48: 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);
40006e4c: 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,
40006e50: c2 05 60 04 ld [ %l5 + 4 ], %g1
40006e54: 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,
40006e58: 92 10 00 17 mov %l7, %o1
40006e5c: 7f ff ed d7 call 400025b8 <.umul>
40006e60: 90 02 00 01 add %o0, %g1, %o0
40006e64: 92 10 00 1d mov %i5, %o1
40006e68: 94 10 00 08 mov %o0, %o2
40006e6c: 96 10 00 19 mov %i1, %o3
40006e70: 90 10 00 1c mov %i4, %o0
40006e74: 7f ff f6 a1 call 400048f8 <rtems_fdisk_seg_read>
40006e78: 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)
40006e7c: 84 92 20 00 orcc %o0, 0, %g2
40006e80: 32 80 00 3d bne,a 40006f74 <rtems_fdisk_ioctl+0x1320> <== NEVER TAKEN
40006e84: 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);
40006e88: 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++)
40006e8c: 80 a0 60 00 cmp %g1, 0
40006e90: 22 80 00 0f be,a 40006ecc <rtems_fdisk_ioctl+0x1278> <== NEVER TAKEN
40006e94: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
40006e98: 05 10 01 26 sethi %hi(0x40049800), %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)
40006e9c: 88 06 40 01 add %i1, %g1, %g4
40006ea0: fa 00 a0 e0 ld [ %g2 + 0xe0 ], %i5
40006ea4: 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;
40006ea8: 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);
40006eac: de 08 c0 00 ldub [ %g3 ], %o7
40006eb0: 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++)
40006eb4: 86 00 e0 01 inc %g3
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40006eb8: 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++)
40006ebc: 80 a0 c0 04 cmp %g3, %g4
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40006ec0: 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++)
40006ec4: 12 bf ff fa bne 40006eac <rtems_fdisk_ioctl+0x1258>
40006ec8: c4 17 40 02 lduh [ %i5 + %g2 ], %g2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
40006ecc: d6 15 80 11 lduh [ %l6 + %l1 ], %o3
40006ed0: 85 28 a0 10 sll %g2, 0x10, %g2
40006ed4: 95 30 a0 10 srl %g2, 0x10, %o2
40006ed8: 80 a2 80 0b cmp %o2, %o3
40006edc: 02 80 00 1c be 40006f4c <rtems_fdisk_ioctl+0x12f8> <== ALWAYS TAKEN
40006ee0: ea 07 bf ec ld [ %fp + -20 ], %l5
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
40006ee4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006ee8: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40006eec: 7f ff f7 3b call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006ef0: 90 12 21 08 or %o0, 0x108, %o0 ! 40034908 <__FUNCTION__.6193+0x840><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006ef4: 10 bf ff c3 b 40006e00 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
40006ef8: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
40006efc: 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);
40006f00: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006f04: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED
40006f08: 7f ff f7 34 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40006f0c: 90 12 20 38 or %o0, 0x38, %o0 ! 40034838 <__FUNCTION__.6193+0x770><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006f10: 10 bf ff bc b 40006e00 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
40006f14: 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,
40006f18: 15 10 00 d1 sethi %hi(0x40034400), %o2
40006f1c: 10 bf ff 9a b 40006d84 <rtems_fdisk_ioctl+0x1130>
40006f20: 82 12 a0 10 or %o2, 0x10, %g1 ! 40034410 <__FUNCTION__.6193+0x348>
bc = &fd->blocks[block];
if (!bc->segment)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
40006f24: 94 10 00 1b mov %i3, %o2
40006f28: 13 10 00 d2 sethi %hi(0x40034800), %o1
40006f2c: 90 10 00 1c mov %i4, %o0
40006f30: 7f ff f6 2e call 400047e8 <rtems_fdisk_info>
40006f34: 92 12 60 60 or %o1, 0x60, %o1
#endif
memset (buffer, 0xff, fd->block_size);
40006f38: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
40006f3c: 90 10 00 19 mov %i1, %o0
40006f40: 40 00 73 91 call 40023d84 <memset>
40006f44: 92 10 20 ff mov 0xff, %o1
40006f48: 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)
40006f4c: a4 04 a0 01 inc %l2
40006f50: 80 a4 80 14 cmp %l2, %l4
40006f54: 12 bf ff 6b bne 40006d00 <rtems_fdisk_ioctl+0x10ac> <== NEVER TAKEN
40006f58: b2 06 40 01 add %i1, %g1, %i1
40006f5c: 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++)
40006f60: a6 04 e0 01 inc %l3
40006f64: 10 bf ff 5c b 40006cd4 <rtems_fdisk_ioctl+0x1080>
40006f68: b0 06 20 10 add %i0, 0x10, %i0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006f6c: 10 bf ff a5 b 40006e00 <rtems_fdisk_ioctl+0x11ac>
40006f70: 92 10 20 00 clr %o1
bc->page + sc->pages_desc, buffer);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40006f74: f6 07 60 0c ld [ %i5 + 0xc ], %i3 <== NOT EXECUTED
40006f78: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
40006f7c: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
40006f80: fa 04 60 04 ld [ %l1 + 4 ], %i5 <== NOT EXECUTED
40006f84: 40 00 78 48 call 400250a4 <strerror> <== NOT EXECUTED
40006f88: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
40006f8c: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
40006f90: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40006f94: c4 23 a0 5c st %g2, [ %sp + 0x5c ] <== NOT EXECUTED
40006f98: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40006f9c: 13 10 00 d2 sethi %hi(0x40034800), %o1 <== NOT EXECUTED
40006fa0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40006fa4: 92 12 60 d0 or %o1, 0xd0, %o1 <== NOT EXECUTED
40006fa8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40006fac: 7f ff f6 0f call 400047e8 <rtems_fdisk_info> <== NOT EXECUTED
40006fb0: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006fb4: 10 bf ff 93 b 40006e00 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
40006fb8: 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++)
40006fbc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006fc0: 02 bf fc 59 be 40006124 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
40006fc4: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
40006fc8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
40006fcc: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40006fd0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006fd4: 02 bf fc 54 be 40006124 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
40006fd8: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
40006fdc: b6 10 20 0c mov 0xc, %i3 <== NOT EXECUTED
40006fe0: 10 80 00 0b b 4000700c <rtems_fdisk_ioctl+0x13b8> <== NOT EXECUTED
40006fe4: 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++)
40006fe8: b8 07 20 01 inc %i4 <== NOT EXECUTED
40006fec: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40006ff0: 1a bf fc 4d bcc 40006124 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
40006ff4: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
40006ff8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
40006ffc: c2 00 40 1b ld [ %g1 + %i3 ], %g1 <== NOT EXECUTED
40007000: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40007004: 02 80 00 0b be 40007030 <rtems_fdisk_ioctl+0x13dc> <== NOT EXECUTED
40007008: b6 06 e0 0c add %i3, 0xc, %i3 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
4000700c: 7f ff fa 1d call 40005880 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
40007010: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (ret)
40007014: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40007018: 22 bf ff f4 be,a 40006fe8 <rtems_fdisk_ioctl+0x1394> <== NOT EXECUTED
4000701c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40007020: 10 bf fc 41 b 40006124 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
40007024: c4 04 20 d8 ld [ %l0 + 0xd8 ], %g2 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
40007028: 10 bf fc 3e b 40006120 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
4000702c: 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;
40007030: 10 bf fc 3c b 40006120 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
40007034: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
40007038: 10 bf fe a2 b 40006ac0 <rtems_fdisk_ioctl+0xe6c> <== NOT EXECUTED
4000703c: ea 07 bf e8 ld [ %fp + -24 ], %l5 <== NOT EXECUTED
40007040: ea 07 bf e8 ld [ %fp + -24 ], %l5
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007044: 10 bf fe a0 b 40006ac4 <rtems_fdisk_ioctl+0xe70>
40007048: 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);
4000704c: 7f ff f9 57 call 400055a8 <rtems_fdisk_compact> <== NOT EXECUTED
40007050: 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)
40007054: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
40007058: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000705c: 32 bf fe 13 bne,a 400068a8 <rtems_fdisk_ioctl+0xc54> <== NOT EXECUTED
40007060: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
40007064: 10 bf fe f7 b 40006c40 <rtems_fdisk_ioctl+0xfec> <== NOT EXECUTED
40007068: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40004e78 <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)
{
40004e78: 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",
40004e7c: 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)
{
40004e80: 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",
40004e84: d4 06 60 08 ld [ %i1 + 8 ], %o2
40004e88: d6 06 60 0c ld [ %i1 + 0xc ], %o3
40004e8c: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
40004e90: da 06 60 1c ld [ %i1 + 0x1c ], %o5
40004e94: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
40004e98: 80 a0 60 00 cmp %g1, 0
40004e9c: 02 80 00 2b be 40004f48 <rtems_fdisk_queue_segment+0xd0> <== ALWAYS TAKEN
40004ea0: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
40004ea4: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
40004ea8: 03 10 00 d0 sethi %hi(0x40034000), %g1 <== NOT EXECUTED
40004eac: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40004eb0: 02 80 00 2b be 40004f5c <rtems_fdisk_queue_segment+0xe4> <== NOT EXECUTED
40004eb4: 82 10 63 f8 or %g1, 0x3f8, %g1 <== NOT EXECUTED
40004eb8: 05 10 00 d1 sethi %hi(0x40034400), %g2
40004ebc: 84 10 a0 08 or %g2, 8, %g2 ! 40034408 <__FUNCTION__.6193+0x340>
40004ec0: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40004ec4: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
40004ec8: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40004ecc: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40004ed0: 90 10 00 18 mov %i0, %o0
40004ed4: 13 10 00 d1 sethi %hi(0x40034400), %o1
40004ed8: 7f ff fe 44 call 400047e8 <rtems_fdisk_info>
40004edc: 92 12 60 18 or %o1, 0x18, %o1 ! 40034418 <__FUNCTION__.6193+0x350>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
40004ee0: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
40004ee4: 80 a0 60 00 cmp %g1, 0
40004ee8: 22 80 00 2c be,a 40004f98 <rtems_fdisk_queue_segment+0x120><== ALWAYS TAKEN
40004eec: 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;
40004ef0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
while (it)
40004ef4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004ef8: 02 80 00 89 be 4000511c <rtems_fdisk_queue_segment+0x2a4> <== NOT EXECUTED
40004efc: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
{
if (it == sc)
40004f00: 32 80 00 06 bne,a 40004f18 <rtems_fdisk_queue_segment+0xa0><== NOT EXECUTED
40004f04: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40004f08: 30 80 00 89 b,a 4000512c <rtems_fdisk_queue_segment+0x2b4><== NOT EXECUTED
40004f0c: 02 80 00 88 be 4000512c <rtems_fdisk_queue_segment+0x2b4> <== NOT EXECUTED
40004f10: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
40004f14: 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)
40004f18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004f1c: 12 bf ff fc bne 40004f0c <rtems_fdisk_queue_segment+0x94> <== NOT EXECUTED
40004f20: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
40004f24: 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;
40004f28: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
40004f2c: f4 20 40 00 st %i2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
40004f30: f4 26 20 5c st %i2, [ %i0 + 0x5c ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40004f34: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 <== NOT EXECUTED
40004f38: 82 00 60 01 inc %g1 <== NOT EXECUTED
40004f3c: c2 26 20 60 st %g1, [ %i0 + 0x60 ] <== NOT EXECUTED
40004f40: 81 c7 e0 08 ret <== NOT EXECUTED
40004f44: 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",
40004f48: c4 06 80 00 ld [ %i2 ], %g2
40004f4c: 03 10 00 d1 sethi %hi(0x40034400), %g1
40004f50: 80 a0 a0 00 cmp %g2, 0
40004f54: 12 bf ff d9 bne 40004eb8 <rtems_fdisk_queue_segment+0x40>
40004f58: 82 10 60 00 mov %g1, %g1
40004f5c: 05 10 00 d1 sethi %hi(0x40034400), %g2
40004f60: 84 10 a0 10 or %g2, 0x10, %g2 ! 40034410 <__FUNCTION__.6193+0x348>
40004f64: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40004f68: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
40004f6c: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40004f70: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40004f74: 90 10 00 18 mov %i0, %o0
40004f78: 13 10 00 d1 sethi %hi(0x40034400), %o1
40004f7c: 7f ff fe 1b call 400047e8 <rtems_fdisk_info>
40004f80: 92 12 60 18 or %o1, 0x18, %o1 ! 40034418 <__FUNCTION__.6193+0x350>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
40004f84: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
40004f88: 80 a0 60 00 cmp %g1, 0
40004f8c: 32 bf ff da bne,a 40004ef4 <rtems_fdisk_queue_segment+0x7c><== NEVER TAKEN
40004f90: 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);
40004f94: 92 10 00 1a mov %i2, %o1
40004f98: b8 06 20 34 add %i0, 0x34, %i4
40004f9c: 7f ff fd 94 call 400045ec <rtems_fdisk_segment_queue_remove>
40004fa0: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
40004fa4: b6 06 20 40 add %i0, 0x40, %i3
40004fa8: 92 10 00 1a mov %i2, %o1
40004fac: 7f ff fd 90 call 400045ec <rtems_fdisk_segment_queue_remove>
40004fb0: 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);
40004fb4: c6 06 a0 1c ld [ %i2 + 0x1c ], %g3
40004fb8: fa 06 a0 14 ld [ %i2 + 0x14 ], %i5
40004fbc: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1
40004fc0: c4 06 a0 24 ld [ %i2 + 0x24 ], %g2
40004fc4: 88 00 40 03 add %g1, %g3, %g4
40004fc8: 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)
40004fcc: 80 a7 40 02 cmp %i5, %g2
40004fd0: 02 80 00 29 be 40005074 <rtems_fdisk_queue_segment+0x1fc>
40004fd4: 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;
40004fd8: f2 06 20 34 ld [ %i0 + 0x34 ], %i1
while (seg)
40004fdc: 80 a6 60 00 cmp %i1, 0
40004fe0: 22 80 00 57 be,a 4000513c <rtems_fdisk_queue_segment+0x2c4>
40004fe4: 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)
40004fe8: f6 06 60 20 ld [ %i1 + 0x20 ], %i3
40004fec: 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);
40004ff0: c8 06 60 14 ld [ %i1 + 0x14 ], %g4
40004ff4: c6 06 60 1c ld [ %i1 + 0x1c ], %g3
40004ff8: 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)
40004ffc: 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);
40005000: 82 21 00 01 sub %g4, %g1, %g1
40005004: 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) <
40005008: 80 a7 40 01 cmp %i5, %g1
4000500c: 3a 80 00 0e bcc,a 40005044 <rtems_fdisk_queue_segment+0x1cc>
40005010: f2 06 40 00 ld [ %i1 ], %i1
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
40005014: 7f ff ff 6f call 40004dd0 <rtems_fdisk_segment_queue_insert_before>
40005018: 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)
4000501c: 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);
40005020: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
40005024: 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)
40005028: 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);
4000502c: 82 20 c0 01 sub %g3, %g1, %g1
40005030: 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) <
40005034: 80 a7 40 01 cmp %i5, %g1
40005038: 0a bf ff f7 bcs 40005014 <rtems_fdisk_queue_segment+0x19c><== NEVER TAKEN
4000503c: 01 00 00 00 nop
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
40005040: 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)
40005044: 80 a6 60 00 cmp %i1, 0
40005048: 32 bf ff f5 bne,a 4000501c <rtems_fdisk_queue_segment+0x1a4>
4000504c: c8 06 60 24 ld [ %i1 + 0x24 ], %g4
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
40005050: 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;
40005054: c0 26 80 00 clr [ %i2 ]
if (queue->head)
{
queue->tail->next = sc;
40005058: f4 20 40 00 st %i2, [ %g1 ]
queue->tail = sc;
4000505c: f4 26 20 38 st %i2, [ %i0 + 0x38 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40005060: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
40005064: 82 00 60 01 inc %g1
40005068: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
4000506c: 81 c7 e0 08 ret
40005070: 81 e8 00 00 restore
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
{
if (sc->pages_active)
40005074: 22 80 00 1b be,a 400050e0 <rtems_fdisk_queue_segment+0x268><== NEVER TAKEN
40005078: 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;
4000507c: f2 06 20 40 ld [ %i0 + 0x40 ], %i1
while (seg)
40005080: 80 a6 60 00 cmp %i1, 0
40005084: 22 80 00 36 be,a 4000515c <rtems_fdisk_queue_segment+0x2e4>
40005088: c0 26 80 00 clr [ %i2 ]
{
if (sc->pages_used > seg->pages_used)
4000508c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40005090: 80 a0 40 02 cmp %g1, %g2
40005094: 28 80 00 07 bleu,a 400050b0 <rtems_fdisk_queue_segment+0x238>
40005098: f2 06 40 00 ld [ %i1 ], %i1
4000509c: 30 80 00 26 b,a 40005134 <rtems_fdisk_queue_segment+0x2bc>
400050a0: 80 a0 80 01 cmp %g2, %g1
400050a4: 0a 80 00 24 bcs 40005134 <rtems_fdisk_queue_segment+0x2bc>
400050a8: 01 00 00 00 nop
break;
seg = seg->next;
400050ac: 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)
400050b0: 80 a6 60 00 cmp %i1, 0
400050b4: 32 bf ff fb bne,a 400050a0 <rtems_fdisk_queue_segment+0x228>
400050b8: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
400050bc: 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;
400050c0: c0 26 80 00 clr [ %i2 ]
if (queue->head)
{
queue->tail->next = sc;
400050c4: f4 20 40 00 st %i2, [ %g1 ]
queue->tail = sc;
400050c8: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
400050cc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
400050d0: 82 00 60 01 inc %g1
400050d4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
400050d8: 81 c7 e0 08 ret
400050dc: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
400050e0: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
400050e4: 02 80 00 19 be 40005148 <rtems_fdisk_queue_segment+0x2d0> <== NOT EXECUTED
400050e8: 01 00 00 00 nop <== NOT EXECUTED
{
if (sc)
{
sc->next = 0;
if (queue->head)
400050ec: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED
400050f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400050f4: 02 80 00 17 be 40005150 <rtems_fdisk_queue_segment+0x2d8> <== NOT EXECUTED
400050f8: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
{
queue->tail->next = sc;
400050fc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 <== NOT EXECUTED
40005100: f4 20 40 00 st %i2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
40005104: f4 26 20 50 st %i2, [ %i0 + 0x50 ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40005108: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED
4000510c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005110: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED
40005114: 81 c7 e0 08 ret <== NOT EXECUTED
40005118: 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;
4000511c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40005120: f4 26 20 5c st %i2, [ %i0 + 0x5c ] <== NOT EXECUTED
40005124: 10 bf ff 84 b 40004f34 <rtems_fdisk_queue_segment+0xbc> <== NOT EXECUTED
40005128: f4 26 20 58 st %i2, [ %i0 + 0x58 ] <== NOT EXECUTED
4000512c: 81 c7 e0 08 ret <== NOT EXECUTED
40005130: 81 e8 00 00 restore <== NOT EXECUTED
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
40005134: 7f ff ff 27 call 40004dd0 <rtems_fdisk_segment_queue_insert_before>
40005138: 91 e8 00 1b restore %g0, %i3, %o0
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
4000513c: f4 26 20 38 st %i2, [ %i0 + 0x38 ]
40005140: 10 bf ff c8 b 40005060 <rtems_fdisk_queue_segment+0x1e8>
40005144: 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);
40005148: 7f ff fe c3 call 40004c54 <rtems_fdisk_erase_segment> <== NOT EXECUTED
4000514c: 93 e8 00 1a restore %g0, %i2, %o1 <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40005150: f4 26 20 50 st %i2, [ %i0 + 0x50 ] <== NOT EXECUTED
40005154: 10 bf ff ed b 40005108 <rtems_fdisk_queue_segment+0x290> <== NOT EXECUTED
40005158: f4 26 20 4c st %i2, [ %i0 + 0x4c ] <== NOT EXECUTED
4000515c: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
40005160: 10 bf ff db b 400050cc <rtems_fdisk_queue_segment+0x254>
40005164: f4 26 20 40 st %i2, [ %i0 + 0x40 ]
40004670 <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;
40004670: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
while (it)
40004674: 80 a0 60 00 cmp %g1, 0
40004678: 12 80 00 07 bne 40004694 <rtems_fdisk_queue_status+0x24> <== ALWAYS TAKEN
4000467c: 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' : '-';
40004680: 10 80 00 0a b 400046a8 <rtems_fdisk_queue_status+0x38> <== NOT EXECUTED
40004684: 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)
40004688: 80 a0 60 00 cmp %g1, 0
4000468c: 02 80 00 06 be 400046a4 <rtems_fdisk_queue_status+0x34> <== ALWAYS TAKEN
40004690: 80 a2 40 01 cmp %o1, %g1
{
if (it == sc)
40004694: 32 bf ff fd bne,a 40004688 <rtems_fdisk_queue_status+0x18>
40004698: 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' : '-';
4000469c: 10 80 00 03 b 400046a8 <rtems_fdisk_queue_status+0x38>
400046a0: 82 10 20 41 mov 0x41, %g1
400046a4: 82 10 20 2d mov 0x2d, %g1
400046a8: 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;
400046ac: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
while (it)
400046b0: 80 a0 60 00 cmp %g1, 0
400046b4: 12 80 00 07 bne 400046d0 <rtems_fdisk_queue_status+0x60> <== ALWAYS TAKEN
400046b8: 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' : '-';
400046bc: 10 80 00 0a b 400046e4 <rtems_fdisk_queue_status+0x74> <== NOT EXECUTED
400046c0: 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)
400046c4: 80 a0 60 00 cmp %g1, 0
400046c8: 02 80 00 06 be 400046e0 <rtems_fdisk_queue_status+0x70>
400046cc: 80 a2 40 01 cmp %o1, %g1
{
if (it == sc)
400046d0: 32 bf ff fd bne,a 400046c4 <rtems_fdisk_queue_status+0x54>
400046d4: 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' : '-';
400046d8: 10 80 00 03 b 400046e4 <rtems_fdisk_queue_status+0x74>
400046dc: 82 10 20 55 mov 0x55, %g1
400046e0: 82 10 20 2d mov 0x2d, %g1
400046e4: 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;
400046e8: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
while (it)
400046ec: 80 a0 60 00 cmp %g1, 0
400046f0: 12 80 00 07 bne 4000470c <rtems_fdisk_queue_status+0x9c> <== NEVER TAKEN
400046f4: 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' : '-';
400046f8: 10 80 00 0a b 40004720 <rtems_fdisk_queue_status+0xb0>
400046fc: 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)
40004700: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004704: 02 80 00 06 be 4000471c <rtems_fdisk_queue_status+0xac> <== NOT EXECUTED
40004708: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
{
if (it == sc)
4000470c: 32 bf ff fd bne,a 40004700 <rtems_fdisk_queue_status+0x90><== NOT EXECUTED
40004710: 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' : '-';
40004714: 10 80 00 03 b 40004720 <rtems_fdisk_queue_status+0xb0> <== NOT EXECUTED
40004718: 82 10 20 45 mov 0x45, %g1 <== NOT EXECUTED
4000471c: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
40004720: 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;
40004724: c2 02 20 58 ld [ %o0 + 0x58 ], %g1
while (it)
40004728: 80 a0 60 00 cmp %g1, 0
4000472c: 12 80 00 07 bne 40004748 <rtems_fdisk_queue_status+0xd8> <== NEVER TAKEN
40004730: 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' : '-';
40004734: 10 80 00 0c b 40004764 <rtems_fdisk_queue_status+0xf4>
40004738: 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)
4000473c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004740: 02 80 00 08 be 40004760 <rtems_fdisk_queue_status+0xf0> <== NOT EXECUTED
40004744: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
{
if (it == sc)
40004748: 32 bf ff fd bne,a 4000473c <rtems_fdisk_queue_status+0xcc><== NOT EXECUTED
4000474c: 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' : '-';
40004750: 82 10 20 46 mov 0x46, %g1 <== NOT EXECUTED
queues[4] = '\0';
40004754: c0 2a a0 04 clrb [ %o2 + 4 ] <== NOT EXECUTED
40004758: 81 c3 e0 08 retl <== NOT EXECUTED
4000475c: 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' : '-';
40004760: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
queues[4] = '\0';
40004764: c0 2a a0 04 clrb [ %o2 + 4 ]
40004768: 81 c3 e0 08 retl
4000476c: c2 2a a0 03 stb %g1, [ %o2 + 3 ]
40005880 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
40005880: 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));
40005884: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
40005888: 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;
4000588c: c0 26 20 38 clr [ %i0 + 0x38 ]
40005890: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
40005894: 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;
40005898: c0 26 20 44 clr [ %i0 + 0x44 ]
4000589c: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
400058a0: 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;
400058a4: c0 26 20 50 clr [ %i0 + 0x50 ]
400058a8: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
400058ac: 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;
400058b0: c0 26 20 5c clr [ %i0 + 0x5c ]
400058b4: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
400058b8: 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));
400058bc: 92 10 20 00 clr %o1
400058c0: 40 00 79 31 call 40023d84 <memset>
400058c4: 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++)
400058c8: 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;
400058cc: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
400058d0: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
400058d4: 80 a0 e0 00 cmp %g3, 0
400058d8: 02 80 00 82 be 40005ae0 <rtems_fdisk_recover_block_mappings+0x260><== NEVER TAKEN
400058dc: ae 10 00 18 mov %i0, %l7
400058e0: 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);
400058e4: 25 10 00 d1 sethi %hi(0x40034400), %l2
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
400058e8: 29 10 00 d1 sethi %hi(0x40034400), %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",
400058ec: 2d 10 00 d1 sethi %hi(0x40034400), %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: " \
400058f0: 27 10 00 d1 sethi %hi(0x40034400), %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,
400058f4: 2b 10 00 d1 sethi %hi(0x40034400), %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++)
400058f8: a2 10 20 00 clr %l1
400058fc: 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);
40005900: a4 14 a3 00 or %l2, 0x300, %l2
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40005904: a8 15 23 70 or %l4, 0x370, %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",
40005908: ac 15 a3 90 or %l6, 0x390, %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: " \
4000590c: a6 14 e3 e8 or %l3, 0x3e8, %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,
40005910: aa 15 63 b8 or %l5, 0x3b8, %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++)
40005914: 82 00 80 11 add %g2, %l1, %g1
40005918: c8 00 60 04 ld [ %g1 + 4 ], %g4
4000591c: a0 10 20 00 clr %l0
40005920: 80 a1 20 00 cmp %g4, 0
40005924: 02 80 00 6b be 40005ad0 <rtems_fdisk_recover_block_mappings+0x250><== NEVER TAKEN
40005928: b4 10 20 00 clr %i2
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
4000592c: 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);
40005930: 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];
40005934: b6 06 c0 10 add %i3, %l0, %i3
const rtems_fdisk_segment_desc* sd = sc->descriptor;
40005938: 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);
4000593c: 96 10 00 1a mov %i2, %o3
40005940: 92 10 00 12 mov %l2, %o1
40005944: 7f ff fb a9 call 400047e8 <rtems_fdisk_info>
40005948: 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;
4000594c: 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);
40005950: 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;
40005954: 7f ff f3 53 call 400026a0 <.udiv>
40005958: 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;
4000595c: 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;
40005960: 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);
40005964: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
40005968: 7f ff f3 4e call 400026a0 <.udiv>
4000596c: 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)
40005970: 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;
40005974: 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;
40005978: 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);
4000597c: 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)
40005980: 80 a0 40 02 cmp %g1, %g2
40005984: 08 80 00 03 bleu 40005990 <rtems_fdisk_recover_block_mappings+0x110>
40005988: c2 26 e0 14 st %g1, [ %i3 + 0x14 ]
fd->starvation_threshold = sc->pages;
4000598c: c2 25 e0 24 st %g1, [ %l7 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
40005990: 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;
40005994: c0 26 e0 1c clr [ %i3 + 0x1c ]
sc->pages_used = 0;
40005998: c0 26 e0 20 clr [ %i3 + 0x20 ]
sc->pages_bad = 0;
4000599c: c0 26 e0 24 clr [ %i3 + 0x24 ]
sc->failed = false;
400059a0: c0 26 e0 28 clr [ %i3 + 0x28 ]
if (!sc->page_descriptors)
400059a4: 80 a7 60 00 cmp %i5, 0
400059a8: 02 80 00 94 be 40005bf8 <rtems_fdisk_recover_block_mappings+0x378><== ALWAYS TAKEN
400059ac: 92 10 00 1c mov %i4, %o1
400059b0: 7f ff f3 02 call 400025b8 <.umul> <== NOT EXECUTED
400059b4: 01 00 00 00 nop <== NOT EXECUTED
400059b8: 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,
400059bc: 90 10 00 17 mov %l7, %o0
400059c0: 92 10 00 1b mov %i3, %o1
400059c4: 94 10 20 00 clr %o2
400059c8: 7f ff fb cc call 400048f8 <rtems_fdisk_seg_read>
400059cc: 96 10 00 1d mov %i5, %o3
sc->pages_desc * fd->block_size);
if (ret)
400059d0: b0 92 20 00 orcc %o0, 0, %i0
400059d4: 12 80 00 95 bne 40005c28 <rtems_fdisk_recover_block_mappings+0x3a8><== NEVER TAKEN
400059d8: 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++)
400059dc: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
400059e0: 80 a0 a0 00 cmp %g2, 0
400059e4: 12 80 00 0a bne 40005a0c <rtems_fdisk_recover_block_mappings+0x18c><== ALWAYS TAKEN
400059e8: b8 10 20 00 clr %i4
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
400059ec: 10 80 00 2f b 40005aa8 <rtems_fdisk_recover_block_mappings+0x228><== NOT EXECUTED
400059f0: 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++;
400059f4: 82 00 60 01 inc %g1 <== NOT EXECUTED
400059f8: 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++)
400059fc: b8 07 20 01 inc %i4
40005a00: 80 a0 80 1c cmp %g2, %i4
40005a04: 08 80 00 28 bleu 40005aa4 <rtems_fdisk_recover_block_mappings+0x224>
40005a08: 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;
40005a0c: c2 07 40 00 ld [ %i5 ], %g1
40005a10: 80 a0 7f ff cmp %g1, -1
40005a14: 22 80 00 35 be,a 40005ae8 <rtems_fdisk_recover_block_mappings+0x268><== ALWAYS TAKEN
40005a18: 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;
40005a1c: 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))
40005a20: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40005a24: 22 bf ff f4 be,a 400059f4 <rtems_fdisk_recover_block_mappings+0x174><== NOT EXECUTED
40005a28: 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))
40005a2c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40005a30: 32 80 00 43 bne,a 40005b3c <rtems_fdisk_recover_block_mappings+0x2bc><== NOT EXECUTED
40005a34: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
40005a38: da 07 60 04 ld [ %i5 + 4 ], %o5 <== NOT EXECUTED
40005a3c: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1 <== NOT EXECUTED
40005a40: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
40005a44: 1a 80 00 57 bcc 40005ba0 <rtems_fdisk_recover_block_mappings+0x320><== NOT EXECUTED
40005a48: 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)
40005a4c: c6 05 e0 18 ld [ %l7 + 0x18 ], %g3 <== NOT EXECUTED
40005a50: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
40005a54: c2 00 c0 0d ld [ %g3 + %o5 ], %g1 <== NOT EXECUTED
40005a58: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005a5c: 02 80 00 5b be 40005bc8 <rtems_fdisk_recover_block_mappings+0x348><== NOT EXECUTED
40005a60: 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: " \
40005a64: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40005a68: d4 00 60 0c ld [ %g1 + 0xc ], %o2 <== NOT EXECUTED
40005a6c: d6 01 20 04 ld [ %g4 + 4 ], %o3 <== NOT EXECUTED
40005a70: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40005a74: f8 23 a0 5c st %i4, [ %sp + 0x5c ] <== NOT EXECUTED
40005a78: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
40005a7c: 7f ff fc 57 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005a80: 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++;
40005a84: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
40005a88: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
40005a8c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005a90: 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++)
40005a94: b8 07 20 01 inc %i4 <== NOT EXECUTED
40005a98: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED
40005a9c: 18 bf ff dc bgu 40005a0c <rtems_fdisk_recover_block_mappings+0x18c><== NOT EXECUTED
40005aa0: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
40005aa4: 90 10 00 17 mov %l7, %o0
40005aa8: 7f ff fc f4 call 40004e78 <rtems_fdisk_queue_segment>
40005aac: 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++)
40005ab0: c4 05 e0 2c ld [ %l7 + 0x2c ], %g2
40005ab4: b4 06 a0 01 inc %i2
40005ab8: 82 00 80 11 add %g2, %l1, %g1
40005abc: c6 00 60 04 ld [ %g1 + 4 ], %g3
40005ac0: 80 a0 c0 1a cmp %g3, %i2
40005ac4: 18 bf ff 9a bgu 4000592c <rtems_fdisk_recover_block_mappings+0xac>
40005ac8: a0 04 20 30 add %l0, 0x30, %l0
40005acc: 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++)
40005ad0: b2 06 60 01 inc %i1
40005ad4: 80 a0 c0 19 cmp %g3, %i1
40005ad8: 18 bf ff 8f bgu 40005914 <rtems_fdisk_recover_block_mappings+0x94><== NEVER TAKEN
40005adc: a2 04 60 0c add %l1, 0xc, %l1
*/
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
40005ae0: 81 c7 e0 08 ret
40005ae4: 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;
40005ae8: 80 a0 7f ff cmp %g1, -1
40005aec: 32 bf ff cd bne,a 40005a20 <rtems_fdisk_recover_block_mappings+0x1a0><== NEVER TAKEN
40005af0: 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);
40005af4: 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,
40005af8: 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,
40005afc: 92 10 00 18 mov %i0, %o1
40005b00: 7f ff f2 ae call 400025b8 <.umul>
40005b04: 90 07 00 08 add %i4, %o0, %o0
40005b08: 92 10 00 1b mov %i3, %o1
40005b0c: 94 10 00 08 mov %o0, %o2
40005b10: 96 10 00 18 mov %i0, %o3
40005b14: 7f ff fb 9b call 40004980 <rtems_fdisk_seg_blank_check>
40005b18: 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)
40005b1c: 80 a2 20 00 cmp %o0, 0
40005b20: 32 80 00 0a bne,a 40005b48 <rtems_fdisk_recover_block_mappings+0x2c8><== NEVER TAKEN
40005b24: da 07 60 04 ld [ %i5 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
40005b28: c2 05 e0 28 ld [ %l7 + 0x28 ], %g1
40005b2c: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
40005b30: 82 00 60 01 inc %g1
40005b34: 10 bf ff b2 b 400059fc <rtems_fdisk_recover_block_mappings+0x17c>
40005b38: c2 25 e0 28 st %g1, [ %l7 + 0x28 ]
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
40005b3c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005b40: 10 bf ff af b 400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005b44: 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",
40005b48: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40005b4c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005b50: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40005b54: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
40005b58: 7f ff fb fe call 40004b50 <rtems_fdisk_warning> <== NOT EXECUTED
40005b5c: 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;
40005b60: 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,
40005b64: 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;
40005b68: 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,
40005b6c: 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;
40005b70: 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,
40005b74: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40005b78: 7f ff fb c9 call 40004a9c <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
40005b7c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
page, pd);
if (ret)
40005b80: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005b84: 12 80 00 17 bne 40005be0 <rtems_fdisk_recover_block_mappings+0x360><== NOT EXECUTED
40005b88: 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++;
40005b8c: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
40005b90: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
40005b94: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005b98: 10 bf ff 99 b 400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005b9c: 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,
40005ba0: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
40005ba4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005ba8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40005bac: 7f ff fb e9 call 40004b50 <rtems_fdisk_warning> <== NOT EXECUTED
40005bb0: 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++;
40005bb4: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
40005bb8: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
40005bbc: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005bc0: 10 bf ff 8f b 400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005bc4: c2 26 e0 24 st %g1, [ %i3 + 0x24 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
40005bc8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
40005bcc: f6 20 c0 0d st %i3, [ %g3 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
40005bd0: f8 21 20 04 st %i4, [ %g4 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
40005bd4: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005bd8: 10 bf ff 89 b 400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005bdc: 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",
40005be0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005be4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40005be8: 7f ff fb fc call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005bec: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
device, segment, page);
}
sc->pages_used++;
40005bf0: 10 bf ff e8 b 40005b90 <rtems_fdisk_recover_block_mappings+0x310><== NOT EXECUTED
40005bf4: 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);
40005bf8: 7f ff f2 70 call 400025b8 <.umul>
40005bfc: 01 00 00 00 nop
40005c00: 40 00 0a 6f call 400085bc <malloc>
40005c04: d0 27 bf fc st %o0, [ %fp + -4 ]
40005c08: d0 26 e0 10 st %o0, [ %i3 + 0x10 ]
40005c0c: ba 10 00 08 mov %o0, %i5
if (!sc->page_descriptors)
40005c10: 80 a2 20 00 cmp %o0, 0
40005c14: 12 bf ff 6a bne 400059bc <rtems_fdisk_recover_block_mappings+0x13c><== ALWAYS TAKEN
40005c18: d8 07 bf fc ld [ %fp + -4 ], %o4
rtems_fdisk_abort ("no memory for page descriptors");
40005c1c: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40005c20: 40 00 06 60 call 400075a0 <rtems_fdisk_abort.constprop.1> <== NOT EXECUTED
40005c24: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 400346e0 <__FUNCTION__.6193+0x618><== 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: " \
40005c28: 40 00 7d 1f call 400250a4 <strerror> <== NOT EXECUTED
40005c2c: 01 00 00 00 nop <== NOT EXECUTED
40005c30: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005c34: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40005c38: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40005c3c: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40005c40: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40005c44: 7f ff fb e5 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005c48: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
40005c4c: 81 c7 e0 08 ret <== NOT EXECUTED
40005c50: 81 e8 00 00 restore <== NOT EXECUTED
40005168 <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)
{
40005168: 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++)
4000516c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
40005170: c0 27 bf f8 clr [ %fp + -8 ]
40005174: 80 a0 e0 00 cmp %g3, 0
40005178: 02 80 00 7f be 40005374 <rtems_fdisk_recycle_segment+0x20c><== NEVER TAKEN
4000517c: 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);
40005180: 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++)
40005184: 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);
40005188: 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];
4000518c: 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,
40005190: 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)
40005194: 80 a6 a0 00 cmp %i2, 0
40005198: 02 80 00 8d be 400053cc <rtems_fdisk_recycle_segment+0x264>
4000519c: 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;
400051a0: 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) &&
400051a4: 80 88 a0 01 btst 1, %g2
400051a8: 32 80 00 6b bne,a 40005354 <rtems_fdisk_recycle_segment+0x1ec><== NEVER TAKEN
400051ac: c4 04 40 10 ld [ %l1 + %l0 ], %g2 <== NOT EXECUTED
400051b0: 80 88 a0 02 btst 2, %g2
400051b4: 22 80 00 68 be,a 40005354 <rtems_fdisk_recycle_segment+0x1ec>
400051b8: 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++)
400051bc: de 06 a0 14 ld [ %i2 + 0x14 ], %o7
400051c0: 80 a3 e0 00 cmp %o7, 0
400051c4: 02 80 00 8d be 400053f8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400051c8: ee 06 a0 10 ld [ %i2 + 0x10 ], %l7
400051cc: 84 10 00 17 mov %l7, %g2
400051d0: 10 80 00 05 b 400051e4 <rtems_fdisk_recycle_segment+0x7c>
400051d4: ba 10 20 00 clr %i5
400051d8: 80 a7 40 0f cmp %i5, %o7
400051dc: 02 80 00 87 be 400053f8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400051e0: 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;
400051e4: c8 00 80 00 ld [ %g2 ], %g4
400051e8: 80 a1 3f ff cmp %g4, -1
400051ec: 32 bf ff fb bne,a 400051d8 <rtems_fdisk_recycle_segment+0x70>
400051f0: ba 07 60 01 inc %i5
400051f4: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400051f8: 80 a1 3f ff cmp %g4, -1
400051fc: 32 bf ff f7 bne,a 400051d8 <rtems_fdisk_recycle_segment+0x70><== NEVER TAKEN
40005200: 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];
40005204: 83 2f 60 03 sll %i5, 3, %g1
40005208: c2 27 bf fc st %g1, [ %fp + -4 ]
active++;
4000520c: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (dpage >= dsc->pages)
40005210: 80 a7 40 0f cmp %i5, %o7
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
40005214: 82 00 60 01 inc %g1
40005218: 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];
4000521c: c2 07 bf fc ld [ %fp + -4 ], %g1
active++;
if (dpage >= dsc->pages)
40005220: 1a 80 00 76 bcc 400053f8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
40005224: 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",
40005228: da 06 a0 08 ld [ %i2 + 8 ], %o5
4000522c: c4 06 a0 0c ld [ %i2 + 0xc ], %g2
40005230: d4 06 60 08 ld [ %i1 + 8 ], %o2
40005234: d6 06 60 0c ld [ %i1 + 0xc ], %o3
40005238: 98 10 00 1c mov %i4, %o4
4000523c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
40005240: 13 10 00 d1 sethi %hi(0x40034400), %o1
40005244: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40005248: 92 12 60 a8 or %o1, 0xa8, %o1
4000524c: 7f ff fd 67 call 400047e8 <rtems_fdisk_info>
40005250: 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,
40005254: 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",
40005258: da 06 a0 08 ld [ %i2 + 8 ], %o5
4000525c: 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,
40005260: 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",
40005264: d4 06 60 08 ld [ %i1 + 8 ], %o2
40005268: 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,
4000526c: a8 07 00 02 add %i4, %g2, %l4
40005270: 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",
40005274: de 23 a0 5c st %o7, [ %sp + 0x5c ]
40005278: 98 10 00 14 mov %l4, %o4
4000527c: 13 10 00 d1 sethi %hi(0x40034400), %o1
40005280: ea 23 a0 60 st %l5, [ %sp + 0x60 ]
40005284: 92 12 60 d0 or %o1, 0xd0, %o1
40005288: 7f ff fd 7a call 40004870 <rtems_fdisk_printf>
4000528c: 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);
40005290: 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,
40005294: 90 10 00 14 mov %l4, %o0
40005298: 92 10 00 0c mov %o4, %o1
4000529c: 7f ff f4 c7 call 400025b8 <.umul>
400052a0: d8 27 bf ec st %o4, [ %fp + -20 ]
400052a4: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
400052a8: d8 07 bf ec ld [ %fp + -20 ], %o4
400052ac: 94 10 00 08 mov %o0, %o2
400052b0: 92 10 00 19 mov %i1, %o1
400052b4: 7f ff fd 91 call 400048f8 <rtems_fdisk_seg_read>
400052b8: 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)
400052bc: 84 92 20 00 orcc %o0, 0, %g2
400052c0: 22 80 00 6a be,a 40005468 <rtems_fdisk_recycle_segment+0x300><== ALWAYS TAKEN
400052c4: 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=>" \
400052c8: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
400052cc: e0 06 a0 0c ld [ %i2 + 0xc ], %l0 <== NOT EXECUTED
400052d0: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
400052d4: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
400052d8: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
400052dc: 40 00 7f 72 call 400250a4 <strerror> <== NOT EXECUTED
400052e0: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
400052e4: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
400052e8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
400052ec: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
400052f0: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400052f4: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
400052f8: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
400052fc: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
40005300: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
40005304: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED
40005308: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000530c: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
40005310: 7f ff fe 32 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005314: 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);
40005318: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000531c: 7f ff fe d7 call 40004e78 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40005320: 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;
40005324: c6 06 20 40 ld [ %i0 + 0x40 ], %g3 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
40005328: 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;
4000532c: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
40005330: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
if (queue->tail == 0)
40005334: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005338: 02 80 00 98 be 40005598 <rtems_fdisk_recycle_segment+0x430><== NOT EXECUTED
4000533c: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
40005340: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
40005344: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005348: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
4000534c: 81 c7 e0 08 ret <== NOT EXECUTED
40005350: 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;
40005354: 80 a0 bf ff cmp %g2, -1
40005358: 22 80 00 16 be,a 400053b0 <rtems_fdisk_recycle_segment+0x248><== NEVER TAKEN
4000535c: c2 05 a0 04 ld [ %l6 + 4 ], %g1 <== NOT EXECUTED
{
--fd->erased_blocks;
}
else
{
used++;
40005360: 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++)
40005364: b8 07 20 01 inc %i4
40005368: 80 a0 c0 1c cmp %g3, %i4
4000536c: 38 bf ff 89 bgu,a 40005190 <rtems_fdisk_recycle_segment+0x28>
40005370: 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",
40005374: d4 06 60 08 ld [ %i1 + 8 ], %o2
40005378: d6 06 60 0c ld [ %i1 + 0xc ], %o3
4000537c: da 07 bf f8 ld [ %fp + -8 ], %o5
40005380: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
40005384: 90 10 00 18 mov %i0, %o0
40005388: 13 10 00 d1 sethi %hi(0x40034400), %o1
4000538c: 98 10 00 1b mov %i3, %o4
40005390: 7f ff fd 38 call 40004870 <rtems_fdisk_printf>
40005394: 92 12 61 90 or %o1, 0x190, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
40005398: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4000539c: 80 a2 60 00 cmp %o1, 0
400053a0: 12 80 00 69 bne 40005544 <rtems_fdisk_recycle_segment+0x3dc><== NEVER TAKEN
400053a4: 11 10 00 d1 sethi %hi(0x40034400), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
400053a8: 7f ff fe 2b call 40004c54 <rtems_fdisk_erase_segment>
400053ac: 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;
400053b0: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
400053b4: 32 bf ff ec bne,a 40005364 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
400053b8: a4 04 a0 01 inc %l2 <== NOT EXECUTED
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
{
--fd->erased_blocks;
400053bc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
400053c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400053c4: 10 bf ff e8 b 40005364 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
400053c8: 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)
400053cc: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
400053d0: 80 a0 a0 00 cmp %g2, 0
400053d4: 22 bf ff 74 be,a 400051a4 <rtems_fdisk_recycle_segment+0x3c><== ALWAYS TAKEN
400053d8: c4 15 a0 02 lduh [ %l6 + 2 ], %g2
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
400053dc: 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");
400053e0: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
400053e4: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
400053e8: 7f ff fd fc call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
400053ec: 90 12 20 50 or %o0, 0x50, %o0 <== NOT EXECUTED
return EIO;
400053f0: 10 bf ff d7 b 4000534c <rtems_fdisk_recycle_segment+0x1e4><== NOT EXECUTED
400053f4: 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,
400053f8: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2 <== NOT EXECUTED
400053fc: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1 <== NOT EXECUTED
40005400: d6 06 a0 24 ld [ %i2 + 0x24 ], %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
40005404: d2 06 a0 08 ld [ %i2 + 8 ], %o1 <== NOT EXECUTED
40005408: 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,
4000540c: 96 02 c0 02 add %o3, %g2, %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
40005410: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
40005414: 96 02 c0 01 add %o3, %g1, %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
40005418: 96 23 c0 0b sub %o7, %o3, %o3 <== NOT EXECUTED
4000541c: 7f ff fd ef call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005420: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
40005424: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
40005428: 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;
4000542c: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
40005430: 7f ff fe 92 call 40004e78 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40005434: 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;
40005438: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
4000543c: 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;
40005440: c4 26 40 00 st %g2, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
40005444: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005448: 02 80 00 56 be 400055a0 <rtems_fdisk_recycle_segment+0x438><== NOT EXECUTED
4000544c: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
queue->tail = sc;
queue->count++;
40005450: 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;
40005454: 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++;
40005458: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000545c: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
40005460: 81 c7 e0 08 ret <== NOT EXECUTED
40005464: 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,
40005468: 90 10 00 18 mov %i0, %o0
4000546c: 92 10 00 1a mov %i2, %o1
40005470: 7f ff fd 9c call 40004ae0 <rtems_fdisk_seg_write_page>
40005474: 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)
40005478: 84 92 20 00 orcc %o0, 0, %g2
4000547c: 12 bf ff 93 bne 400052c8 <rtems_fdisk_recycle_segment+0x160><== NEVER TAKEN
40005480: 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;
40005484: c4 04 40 10 ld [ %l1 + %l0 ], %g2
ret = rtems_fdisk_seg_write_page_desc (fd,
40005488: 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;
4000548c: c4 25 c0 01 st %g2, [ %l7 + %g1 ]
40005490: c4 05 a0 04 ld [ %l6 + 4 ], %g2
ret = rtems_fdisk_seg_write_page_desc (fd,
40005494: 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;
40005498: c4 24 e0 04 st %g2, [ %l3 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
4000549c: 94 10 00 1d mov %i5, %o2
400054a0: 7f ff fd 7f call 40004a9c <rtems_fdisk_seg_write_page_desc>
400054a4: 96 10 00 13 mov %l3, %o3
dsc,
dpage, dpd);
if (ret)
400054a8: 84 92 20 00 orcc %o0, 0, %g2
400054ac: 32 80 00 2a bne,a 40005554 <rtems_fdisk_recycle_segment+0x3ec><== NEVER TAKEN
400054b0: 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++;
400054b4: 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++;
400054b8: 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++;
400054bc: 84 00 a0 01 inc %g2
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400054c0: 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++;
400054c4: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400054c8: 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--;
400054cc: c8 06 60 1c ld [ %i1 + 0x1c ], %g4
ssc->pages_used++;
400054d0: 86 00 e0 01 inc %g3
fd->blocks[spd->block].segment = dsc;
400054d4: 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++;
400054d8: 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--;
400054dc: 88 01 3f ff add %g4, -1, %g4
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400054e0: 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--;
400054e4: c8 26 60 1c st %g4, [ %i1 + 0x1c ]
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400054e8: f4 20 80 01 st %i2, [ %g2 + %g1 ]
fd->blocks[spd->block].page = dpage;
400054ec: fa 20 e0 04 st %i5, [ %g3 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
400054f0: 90 10 00 18 mov %i0, %o0
400054f4: 7f ff fe 61 call 40004e78 <rtems_fdisk_queue_segment>
400054f8: 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);
400054fc: c8 06 a0 20 ld [ %i2 + 0x20 ], %g4
40005500: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
40005504: 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)
40005508: 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);
4000550c: 82 01 00 01 add %g4, %g1, %g1
40005510: 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)
40005514: 80 a0 80 01 cmp %g2, %g1
40005518: 02 80 00 07 be 40005534 <rtems_fdisk_recycle_segment+0x3cc>
4000551c: 01 00 00 00 nop
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
40005520: c2 06 c0 00 ld [ %i3 ], %g1
40005524: 82 00 7f ff add %g1, -1, %g1
40005528: 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))
{
4000552c: 10 bf ff 8e b 40005364 <rtems_fdisk_recycle_segment+0x1fc>
40005530: 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);
40005534: 7f ff fc 8f call 40004770 <rtems_fdisk_seg_most_available>
40005538: d0 07 bf f4 ld [ %fp + -12 ], %o0
4000553c: 10 bf ff f9 b 40005520 <rtems_fdisk_recycle_segment+0x3b8>
40005540: 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",
40005544: 7f ff fd a5 call 40004bd8 <rtems_fdisk_error> <== NOT EXECUTED
40005548: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
4000554c: 7f ff fd c2 call 40004c54 <rtems_fdisk_erase_segment> <== NOT EXECUTED
40005550: 81 e8 00 00 restore <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
40005554: e0 06 a0 0c ld [ %i2 + 0xc ], %l0 <== NOT EXECUTED
40005558: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
4000555c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
40005560: 40 00 7e d1 call 400250a4 <strerror> <== NOT EXECUTED
40005564: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
40005568: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
4000556c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
40005570: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
40005574: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED
40005578: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000557c: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
40005580: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
40005584: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
40005588: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED
4000558c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40005590: 10 bf ff 60 b 40005310 <rtems_fdisk_recycle_segment+0x1a8><== NOT EXECUTED
40005594: 90 12 21 48 or %o0, 0x148, %o0 <== NOT EXECUTED
{
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
40005598: 10 bf ff 6a b 40005340 <rtems_fdisk_recycle_segment+0x1d8><== NOT EXECUTED
4000559c: f2 26 20 44 st %i1, [ %i0 + 0x44 ] <== NOT EXECUTED
400055a0: 10 bf ff ac b 40005450 <rtems_fdisk_recycle_segment+0x2e8><== NOT EXECUTED
400055a4: f2 26 20 44 st %i1, [ %i0 + 0x44 ] <== NOT EXECUTED
40004a04 <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)
{
40004a04: 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;
40004a08: 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;
40004a0c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40004a10: 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;
40004a14: 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;
40004a18: 83 2c 20 02 sll %l0, 2, %g1
40004a1c: 82 20 c0 01 sub %g3, %g1, %g1
40004a20: 86 00 80 01 add %g2, %g1, %g3
40004a24: 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;
40004a28: 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;
40004a2c: 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;
40004a30: 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;
40004a34: 87 2f 60 06 sll %i5, 6, %g3
40004a38: 84 20 c0 02 sub %g3, %g2, %g2
40004a3c: 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",
40004a40: 94 10 00 10 mov %l0, %o2
40004a44: 96 10 00 1d mov %i5, %o3
40004a48: 98 10 00 1a mov %i2, %o4
40004a4c: 9a 10 00 1c mov %i4, %o5
40004a50: 90 10 00 18 mov %i0, %o0
40004a54: 13 10 00 d0 sethi %hi(0x40034000), %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;
40004a58: 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",
40004a5c: 7f ff ff 85 call 40004870 <rtems_fdisk_printf>
40004a60: 92 12 63 78 or %o1, 0x378, %o1
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
40004a64: c2 04 60 04 ld [ %l1 + 4 ], %g1
40004a68: 90 10 00 18 mov %i0, %o0
40004a6c: 92 10 00 10 mov %l0, %o1
40004a70: 94 10 00 1d mov %i5, %o2
40004a74: 96 10 00 1a mov %i2, %o3
40004a78: 98 10 00 1b mov %i3, %o4
40004a7c: 9f c0 40 00 call %g1
40004a80: 9a 10 00 1c mov %i4, %o5
if (ret)
40004a84: b0 92 20 00 orcc %o0, 0, %i0
40004a88: 02 80 00 03 be 40004a94 <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
40004a8c: 82 10 20 01 mov 1, %g1
sc->failed = true;
40004a90: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
40004a94: 81 c7 e0 08 ret
40004a98: 81 e8 00 00 restore
40004ae0 <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)
{
40004ae0: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
40004ae4: c2 06 20 08 ld [ %i0 + 8 ], %g1
40004ae8: 80 88 60 08 btst 8, %g1
40004aec: 22 80 00 0f be,a 40004b28 <rtems_fdisk_seg_write_page+0x48><== NEVER TAKEN
40004af0: 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);
40004af4: 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,
40004af8: 90 10 00 1a mov %i2, %o0
40004afc: 7f ff f6 af call 400025b8 <.umul>
40004b00: 92 10 00 1d mov %i5, %o1
40004b04: 92 10 00 19 mov %i1, %o1
40004b08: 94 10 00 08 mov %o0, %o2
40004b0c: 96 10 00 1d mov %i5, %o3
40004b10: 7f ff ff 9c call 40004980 <rtems_fdisk_seg_blank_check>
40004b14: 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)
40004b18: 80 a2 20 00 cmp %o0, 0
40004b1c: 12 80 00 0b bne 40004b48 <rtems_fdisk_seg_write_page+0x68><== NEVER TAKEN
40004b20: 01 00 00 00 nop
return ret;
}
--fd->erased_blocks;
40004b24: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
40004b28: 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;
40004b2c: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
40004b30: 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;
40004b34: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
40004b38: 7f ff f6 a0 call 400025b8 <.umul>
40004b3c: 92 10 00 1c mov %i4, %o1
40004b40: 7f ff ff b1 call 40004a04 <rtems_fdisk_seg_write>
40004b44: 95 e8 00 08 restore %g0, %o0, %o2
page * fd->block_size, buffer, fd->block_size);
}
40004b48: 81 c7 e0 08 ret <== NOT EXECUTED
40004b4c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40004a9c <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)
{
40004a9c: 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))
40004aa0: c2 06 20 08 ld [ %i0 + 8 ], %g1
40004aa4: 80 88 60 08 btst 8, %g1
40004aa8: 02 80 00 0a be 40004ad0 <rtems_fdisk_seg_write_page_desc+0x34><== NEVER TAKEN
40004aac: b5 2e a0 03 sll %i2, 3, %i2
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
40004ab0: 90 10 00 18 mov %i0, %o0
40004ab4: 92 10 00 19 mov %i1, %o1
40004ab8: 94 10 00 1a mov %i2, %o2
40004abc: 7f ff ff b1 call 40004980 <rtems_fdisk_seg_blank_check>
40004ac0: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
40004ac4: 80 a2 20 00 cmp %o0, 0
40004ac8: 12 80 00 04 bne 40004ad8 <rtems_fdisk_seg_write_page_desc+0x3c><== NEVER TAKEN
40004acc: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
40004ad0: 7f ff ff cd call 40004a04 <rtems_fdisk_seg_write>
40004ad4: 99 e8 20 08 restore %g0, 8, %o4
page_desc, sizeof (rtems_fdisk_page_desc));
}
40004ad8: 81 c7 e0 08 ret <== NOT EXECUTED
40004adc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40004dd0 <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)
40004dd0: 80 a2 60 00 cmp %o1, 0
40004dd4: 02 80 00 12 be 40004e1c <rtems_fdisk_segment_queue_insert_before+0x4c><== NEVER TAKEN
40004dd8: 80 a2 a0 00 cmp %o2, 0
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
40004ddc: c4 02 00 00 ld [ %o0 ], %g2
while (it)
40004de0: 80 a0 a0 00 cmp %g2, 0
40004de4: 02 80 00 0d be 40004e18 <rtems_fdisk_segment_queue_insert_before+0x48><== NEVER TAKEN
40004de8: 80 a2 40 02 cmp %o1, %g2
{
if (item == it)
40004dec: 32 80 00 08 bne,a 40004e0c <rtems_fdisk_segment_queue_insert_before+0x3c>
40004df0: 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;
40004df4: 10 80 00 18 b 40004e54 <rtems_fdisk_segment_queue_insert_before+0x84>
40004df8: 84 10 00 08 mov %o0, %g2
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
{
if (item == it)
40004dfc: 22 80 00 17 be,a 40004e58 <rtems_fdisk_segment_queue_insert_before+0x88><== ALWAYS TAKEN
40004e00: c2 02 20 08 ld [ %o0 + 8 ], %g1
40004e04: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
queue->count++;
return;
}
prev = &it->next;
it = it->next;
40004e08: 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)
40004e0c: 80 a0 60 00 cmp %g1, 0
40004e10: 12 bf ff fb bne 40004dfc <rtems_fdisk_segment_queue_insert_before+0x2c><== ALWAYS TAKEN
40004e14: 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)
40004e18: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED
40004e1c: 02 80 00 0c be 40004e4c <rtems_fdisk_segment_queue_insert_before+0x7c><== NOT EXECUTED
40004e20: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
40004e24: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
40004e28: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004e2c: 02 80 00 10 be 40004e6c <rtems_fdisk_segment_queue_insert_before+0x9c><== NOT EXECUTED
40004e30: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
{
queue->tail->next = sc;
40004e34: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
40004e38: d4 20 40 00 st %o2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
40004e3c: d4 22 20 04 st %o2, [ %o0 + 4 ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40004e40: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
40004e44: 82 00 60 01 inc %g1 <== NOT EXECUTED
40004e48: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
40004e4c: 81 c3 e0 08 retl <== NOT EXECUTED
40004e50: 01 00 00 00 nop <== NOT EXECUTED
{
if (item == it)
{
sc->next = item;
*prev = sc;
queue->count++;
40004e54: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
40004e58: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
40004e5c: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
40004e60: 82 00 60 01 inc %g1
return;
40004e64: 81 c3 e0 08 retl
40004e68: c2 22 20 08 st %g1, [ %o0 + 8 ]
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40004e6c: d4 22 20 04 st %o2, [ %o0 + 4 ] <== NOT EXECUTED
40004e70: 10 bf ff f4 b 40004e40 <rtems_fdisk_segment_queue_insert_before+0x70><== NOT EXECUTED
40004e74: d4 22 00 00 st %o2, [ %o0 ] <== NOT EXECUTED
400045ec <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;
400045ec: c4 02 00 00 ld [ %o0 ], %g2
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
400045f0: 80 a0 a0 00 cmp %g2, 0
400045f4: 02 80 00 0d be 40004628 <rtems_fdisk_segment_queue_remove+0x3c>
400045f8: 80 a0 80 09 cmp %g2, %o1
{
if (sc == it)
400045fc: 32 80 00 08 bne,a 4000461c <rtems_fdisk_segment_queue_remove+0x30>
40004600: c2 00 80 00 ld [ %g2 ], %g1
{
if (prev == 0)
{
queue->head = sc->next;
40004604: 10 80 00 16 b 4000465c <rtems_fdisk_segment_queue_remove+0x70>
40004608: c2 02 40 00 ld [ %o1 ], %g1
* Do not change sc->next as sc could be on another queue.
*/
while (it)
{
if (sc == it)
4000460c: 22 80 00 09 be,a 40004630 <rtems_fdisk_segment_queue_remove+0x44>
40004610: c6 02 40 00 ld [ %o1 ], %g3
40004614: 84 10 00 01 mov %g1, %g2
queue->count--;
break;
}
prev = it;
it = it->next;
40004618: c2 00 80 00 ld [ %g2 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
4000461c: 80 a0 60 00 cmp %g1, 0
40004620: 12 bf ff fb bne 4000460c <rtems_fdisk_segment_queue_remove+0x20>
40004624: 80 a2 40 01 cmp %o1, %g1
40004628: 81 c3 e0 08 retl
4000462c: 01 00 00 00 nop
queue->tail = 0;
}
else
{
prev->next = sc->next;
if (queue->tail == sc)
40004630: c2 02 20 04 ld [ %o0 + 4 ], %g1
40004634: 80 a0 40 09 cmp %g1, %o1
40004638: 02 80 00 07 be 40004654 <rtems_fdisk_segment_queue_remove+0x68><== ALWAYS TAKEN
4000463c: c6 20 80 00 st %g3, [ %g2 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
40004640: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
40004644: c0 22 40 00 clr [ %o1 ]
queue->count--;
40004648: 82 00 7f ff add %g1, -1, %g1
break;
4000464c: 81 c3 e0 08 retl
40004650: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
else
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
40004654: 10 bf ff fb b 40004640 <rtems_fdisk_segment_queue_remove+0x54>
40004658: c4 22 20 04 st %g2, [ %o0 + 4 ]
if (sc == it)
{
if (prev == 0)
{
queue->head = sc->next;
if (queue->head == 0)
4000465c: 80 a0 60 00 cmp %g1, 0
40004660: 12 bf ff f8 bne 40004640 <rtems_fdisk_segment_queue_remove+0x54>
40004664: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
40004668: 10 bf ff f6 b 40004640 <rtems_fdisk_segment_queue_remove+0x54>
4000466c: c0 22 20 04 clr [ %o0 + 4 ]
40004b50 <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, ...)
{
40004b50: 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);
40004b54: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40004b58: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40004b5c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40004b60: 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)
40004b64: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
40004b68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004b6c: 02 80 00 19 be 40004bd0 <rtems_fdisk_warning+0x80> <== NOT EXECUTED
40004b70: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
40004b74: 3b 10 00 e4 sethi %hi(0x40039000), %i5 <== NOT EXECUTED
40004b78: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 ! 40039370 <_impure_ptr><== NOT EXECUTED
40004b7c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40004b80: 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);
40004b84: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
40004b88: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
40004b8c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
40004b90: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED
40004b94: 40 00 7b 65 call 40023928 <fwrite> <== NOT EXECUTED
40004b98: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 400343a0 <__FUNCTION__.6193+0x2d8><== NOT EXECUTED
ret = vfprintf (stdout, format, args);
40004b9c: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 <== NOT EXECUTED
40004ba0: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
40004ba4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40004ba8: 40 00 9c c5 call 4002bebc <vfprintf> <== NOT EXECUTED
40004bac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
40004bb0: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
40004bb4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
40004bb8: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40004bbc: 40 00 79 7a call 400231a4 <fputc> <== NOT EXECUTED
40004bc0: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
40004bc4: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 <== NOT EXECUTED
40004bc8: 40 00 78 5f call 40022d44 <fflush> <== NOT EXECUTED
40004bcc: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40004bd0: 81 c7 e0 08 ret <== NOT EXECUTED
40004bd4: 81 e8 00 00 restore <== NOT EXECUTED
4000c250 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
4000c250: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
4000c254: 7f ff fe fa call 4000be3c <geteuid>
4000c258: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
4000c25c: 91 2a 20 10 sll %o0, 0x10, %o0
4000c260: 91 32 20 10 srl %o0, 0x10, %o0
4000c264: 80 a2 00 1a cmp %o0, %i2
4000c268: 12 80 00 08 bne 4000c288 <rtems_filesystem_check_access+0x38>
4000c26c: 80 a2 20 00 cmp %o0, 0
perm_flags <<= RTEMS_FS_USR_SHIFT;
4000c270: b1 2e 20 06 sll %i0, 6, %i0
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
4000c274: b0 2e 00 19 andn %i0, %i1, %i0
}
4000c278: 80 a0 00 18 cmp %g0, %i0
4000c27c: b0 60 3f ff subx %g0, -1, %i0
4000c280: 81 c7 e0 08 ret
4000c284: 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) {
4000c288: 22 bf ff fb be,a 4000c274 <rtems_filesystem_check_access+0x24>
4000c28c: b1 2e 20 06 sll %i0, 6, %i0
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
4000c290: 7f ff fe e7 call 4000be2c <getegid>
4000c294: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
4000c298: 91 2a 20 10 sll %o0, 0x10, %o0
4000c29c: 91 32 20 10 srl %o0, 0x10, %o0
4000c2a0: 80 a2 00 1b cmp %o0, %i3
4000c2a4: 12 80 00 08 bne 4000c2c4 <rtems_filesystem_check_access+0x74>
4000c2a8: 80 a2 20 00 cmp %o0, 0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
4000c2ac: b1 2e 20 03 sll %i0, 3, %i0
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
4000c2b0: b0 2e 00 19 andn %i0, %i1, %i0
}
4000c2b4: 80 a0 00 18 cmp %g0, %i0
4000c2b8: b0 60 3f ff subx %g0, -1, %i0
4000c2bc: 81 c7 e0 08 ret
4000c2c0: 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) {
4000c2c4: 32 bf ff ed bne,a 4000c278 <rtems_filesystem_check_access+0x28><== ALWAYS TAKEN
4000c2c8: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
4000c2cc: 10 bf ff f9 b 4000c2b0 <rtems_filesystem_check_access+0x60><== NOT EXECUTED
4000c2d0: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
40004550 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40004550: 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 );
40004554: 3b 10 00 7b sethi %hi(0x4001ec00), %i5
40004558: d0 07 61 38 ld [ %i5 + 0x138 ], %o0 ! 4001ed38 <rtems_libio_semaphore>
4000455c: 92 10 20 00 clr %o1
40004560: 40 00 0b 8b call 4000738c <rtems_semaphore_obtain>
40004564: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40004568: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
4000456c: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
40004570: d0 07 61 38 ld [ %i5 + 0x138 ], %o0
next->previous = previous;
40004574: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40004578: 40 00 0b d4 call 400074c8 <rtems_semaphore_release>
4000457c: 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);
40004580: 40 00 00 6d call 40004734 <rtems_filesystem_global_location_release>
40004584: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
40004588: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000458c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40004590: 9f c0 40 00 call %g1
40004594: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
40004598: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
4000459c: 80 a2 20 00 cmp %o0, 0
400045a0: 02 80 00 07 be 400045bc <rtems_filesystem_do_unmount+0x6c><== NEVER TAKEN
400045a4: 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 );
400045a8: 40 00 0b f3 call 40007574 <rtems_event_system_send>
400045ac: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
400045b0: 80 a2 20 00 cmp %o0, 0
400045b4: 32 80 00 04 bne,a 400045c4 <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
400045b8: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
400045bc: 7f ff fa 9b call 40003028 <free>
400045c0: 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);
400045c4: 40 00 0d 57 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
400045c8: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
4000c500 <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;
4000c500: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
4000c504: c6 02 20 04 ld [ %o0 + 4 ], %g3
4000c508: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000c50c: 80 a0 40 03 cmp %g1, %g3
4000c510: 32 80 00 08 bne,a 4000c530 <rtems_filesystem_eval_path_eat_delimiter+0x30><== ALWAYS TAKEN
4000c514: c4 48 40 00 ldsb [ %g1 ], %g2
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000c518: 10 80 00 0d b 4000c54c <rtems_filesystem_eval_path_eat_delimiter+0x4c><== NOT EXECUTED
4000c51c: 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)) {
4000c520: 80 a0 c0 01 cmp %g3, %g1
4000c524: 22 80 00 0a be,a 4000c54c <rtems_filesystem_eval_path_eat_delimiter+0x4c>
4000c528: 86 20 c0 01 sub %g3, %g1, %g3
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
4000c52c: c4 48 40 00 ldsb [ %g1 ], %g2
4000c530: 80 a0 a0 5c cmp %g2, 0x5c
4000c534: 22 bf ff fb be,a 4000c520 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000c538: 82 00 60 01 inc %g1
4000c53c: 80 a0 a0 2f cmp %g2, 0x2f
4000c540: 22 bf ff f8 be,a 4000c520 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000c544: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000c548: 86 20 c0 01 sub %g3, %g1, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000c54c: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000c550: 81 c3 e0 08 retl
4000c554: c6 22 20 04 st %g3, [ %o0 + 4 ]
4000c308 <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
)
{
4000c308: 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);
4000c30c: 03 10 00 74 sethi %hi(0x4001d000), %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 =
4000c310: 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);
4000c314: a2 10 63 d0 or %g1, 0x3d0, %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);
4000c318: 03 10 00 73 sethi %hi(0x4001cc00), %g1
4000c31c: a0 10 63 38 or %g1, 0x338, %l0 ! 4001cf38 <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);
4000c320: 40 00 00 8e call 4000c558 <rtems_filesystem_eval_path_next_token>
4000c324: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
4000c328: 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) {
4000c32c: 80 a7 60 00 cmp %i5, 0
4000c330: 02 80 00 18 be 4000c390 <rtems_filesystem_eval_path_generic+0x88>
4000c334: f8 06 20 08 ld [ %i0 + 8 ], %i4
if ((*config->is_directory)(ctx, arg)) {
4000c338: c2 06 80 00 ld [ %i2 ], %g1
4000c33c: 90 10 00 18 mov %i0, %o0
4000c340: 9f c0 40 00 call %g1
4000c344: 92 10 00 19 mov %i1, %o1
4000c348: 80 8a 20 ff btst 0xff, %o0
4000c34c: 02 80 00 13 be 4000c398 <rtems_filesystem_eval_path_generic+0x90>
4000c350: 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] == '.';
4000c354: 02 80 00 23 be 4000c3e0 <rtems_filesystem_eval_path_generic+0xd8>
4000c358: 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] == '.';
4000c35c: 22 80 00 2f be,a 4000c418 <rtems_filesystem_eval_path_generic+0x110>
4000c360: c2 4f 00 00 ldsb [ %i4 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
4000c364: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000c368: 90 10 00 18 mov %i0, %o0
4000c36c: 92 10 00 19 mov %i1, %o1
4000c370: 94 10 00 1c mov %i4, %o2
4000c374: 9f c0 40 00 call %g1
4000c378: 96 10 00 1d mov %i5, %o3
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000c37c: 80 a2 20 02 cmp %o0, 2
4000c380: 02 80 00 08 be 4000c3a0 <rtems_filesystem_eval_path_generic+0x98>
4000c384: 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) {
4000c388: 02 bf ff e6 be 4000c320 <rtems_filesystem_eval_path_generic+0x18>
4000c38c: 01 00 00 00 nop
4000c390: 81 c7 e0 08 ret
4000c394: 81 e8 00 00 restore
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
4000c398: 7f ff de fd call 40003f8c <rtems_filesystem_eval_path_error>
4000c39c: 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)) {
4000c3a0: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000c3a4: 80 a0 60 00 cmp %g1, 0
4000c3a8: 02 bf ff fa be 4000c390 <rtems_filesystem_eval_path_generic+0x88>
4000c3ac: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
4000c3b0: 40 00 00 54 call 4000c500 <rtems_filesystem_eval_path_eat_delimiter>
4000c3b4: 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
4000c3b8: 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 (
4000c3bc: 80 88 60 80 btst 0x80, %g1
4000c3c0: 02 80 00 06 be 4000c3d8 <rtems_filesystem_eval_path_generic+0xd0>
4000c3c4: 01 00 00 00 nop
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
4000c3c8: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000c3cc: 80 a0 60 00 cmp %g1, 0
4000c3d0: 02 bf ff f0 be 4000c390 <rtems_filesystem_eval_path_generic+0x88>
4000c3d4: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000c3d8: 7f ff de ed call 40003f8c <rtems_filesystem_eval_path_error>
4000c3dc: 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] == '.';
4000c3e0: c2 4f 00 00 ldsb [ %i4 ], %g1
4000c3e4: 80 a0 60 2e cmp %g1, 0x2e
4000c3e8: 32 bf ff e0 bne,a 4000c368 <rtems_filesystem_eval_path_generic+0x60>
4000c3ec: 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)) {
4000c3f0: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000c3f4: 80 a0 60 00 cmp %g1, 0
4000c3f8: 32 80 00 2c bne,a 4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0>
4000c3fc: 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) {
4000c400: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000c404: 80 88 a1 00 btst 0x100, %g2
4000c408: 22 80 00 28 be,a 4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0>
4000c40c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
4000c410: 7f ff de df call 40003f8c <rtems_filesystem_eval_path_error>
4000c414: 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] == '.';
4000c418: 80 a0 60 2e cmp %g1, 0x2e
4000c41c: 32 bf ff d3 bne,a 4000c368 <rtems_filesystem_eval_path_generic+0x60>
4000c420: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000c424: c2 4f 20 01 ldsb [ %i4 + 1 ], %g1
4000c428: 80 a0 60 2e cmp %g1, 0x2e
4000c42c: 32 bf ff cf bne,a 4000c368 <rtems_filesystem_eval_path_generic+0x60><== NEVER TAKEN
4000c430: 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;
4000c434: 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;
4000c438: 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 );
4000c43c: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
4000c440: 80 a0 80 01 cmp %g2, %g1
4000c444: 22 80 00 27 be,a 4000c4e0 <rtems_filesystem_eval_path_generic+0x1d8>
4000c448: 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 );
4000c44c: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
4000c450: d2 00 a0 24 ld [ %g2 + 0x24 ], %o1
4000c454: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000c458: 9f c0 40 00 call %g1
4000c45c: 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)) {
4000c460: 80 8a 20 ff btst 0xff, %o0
4000c464: 22 80 00 18 be,a 4000c4c4 <rtems_filesystem_eval_path_generic+0x1bc>
4000c468: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
4000c46c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
4000c470: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
4000c474: 80 a0 a0 00 cmp %g2, 0
4000c478: 22 80 00 0c be,a 4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0><== NEVER TAKEN
4000c47c: 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;
4000c480: c4 06 20 0c ld [ %i0 + 0xc ], %g2
ctx->path -= tokenlen;
4000c484: c6 06 00 00 ld [ %i0 ], %g3
ctx->pathlen += tokenlen;
4000c488: c8 06 20 04 ld [ %i0 + 4 ], %g4
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
4000c48c: 86 20 c0 02 sub %g3, %g2, %g3
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
4000c490: c0 26 20 0c clr [ %i0 + 0xc ]
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
ctx->pathlen += tokenlen;
4000c494: 84 01 00 02 add %g4, %g2, %g2
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
4000c498: c6 26 00 00 st %g3, [ %i0 ]
ctx->pathlen += tokenlen;
4000c49c: c4 26 20 04 st %g2, [ %i0 + 4 ]
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
4000c4a0: 7f ff df ca call 400043c8 <rtems_filesystem_eval_path_restart>
4000c4a4: 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);
4000c4a8: 90 10 00 18 mov %i0, %o0
4000c4ac: 92 10 00 19 mov %i1, %o1
4000c4b0: 94 10 00 10 mov %l0, %o2
4000c4b4: 9f c0 40 00 call %g1
4000c4b8: 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) {
4000c4bc: 10 bf ff b1 b 4000c380 <rtems_filesystem_eval_path_generic+0x78>
4000c4c0: 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);
4000c4c4: 90 10 00 18 mov %i0, %o0
4000c4c8: 92 10 00 19 mov %i1, %o1
4000c4cc: 94 10 00 11 mov %l1, %o2
4000c4d0: 9f c0 40 00 call %g1
4000c4d4: 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) {
4000c4d8: 10 bf ff aa b 4000c380 <rtems_filesystem_eval_path_generic+0x78>
4000c4dc: 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 );
4000c4e0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000c4e4: 9f c0 40 00 call %g1
4000c4e8: 90 10 00 1b mov %i3, %o0
4000c4ec: 80 8a 20 ff btst 0xff, %o0
4000c4f0: 32 bf ff ee bne,a 4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0>
4000c4f4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000c4f8: 10 bf ff d5 b 4000c44c <rtems_filesystem_eval_path_generic+0x144>
4000c4fc: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
4000c558 <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;
4000c558: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
4000c55c: c8 02 20 04 ld [ %o0 + 4 ], %g4
4000c560: 88 00 40 04 add %g1, %g4, %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000c564: 80 a0 40 04 cmp %g1, %g4
4000c568: 22 80 00 10 be,a 4000c5a8 <rtems_filesystem_eval_path_next_token+0x50>
4000c56c: 88 21 00 01 sub %g4, %g1, %g4
4000c570: c4 48 40 00 ldsb [ %g1 ], %g2
4000c574: 80 a0 a0 2f cmp %g2, 0x2f
4000c578: 22 80 00 08 be,a 4000c598 <rtems_filesystem_eval_path_next_token+0x40>
4000c57c: 82 00 60 01 inc %g1
4000c580: 10 80 00 38 b 4000c660 <rtems_filesystem_eval_path_next_token+0x108>
4000c584: 80 a0 a0 5c cmp %g2, 0x5c
4000c588: 80 a0 a0 5c cmp %g2, 0x5c
4000c58c: 12 80 00 26 bne 4000c624 <rtems_filesystem_eval_path_next_token+0xcc>
4000c590: 80 a0 a0 2f cmp %g2, 0x2f
++current;
4000c594: 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)) {
4000c598: 80 a1 00 01 cmp %g4, %g1
4000c59c: 32 bf ff fb bne,a 4000c588 <rtems_filesystem_eval_path_next_token+0x30>
4000c5a0: c4 48 40 00 ldsb [ %g1 ], %g2
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000c5a4: 88 21 00 01 sub %g4, %g1, %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000c5a8: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000c5ac: 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;
4000c5b0: 88 00 40 04 add %g1, %g4, %g4
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000c5b4: 80 a1 00 01 cmp %g4, %g1
4000c5b8: 02 80 00 27 be 4000c654 <rtems_filesystem_eval_path_next_token+0xfc>
4000c5bc: 9a 10 00 01 mov %g1, %o5
4000c5c0: c4 48 40 00 ldsb [ %g1 ], %g2
4000c5c4: 80 a0 a0 5c cmp %g2, 0x5c
4000c5c8: 02 80 00 23 be 4000c654 <rtems_filesystem_eval_path_next_token+0xfc><== NEVER TAKEN
4000c5cc: 80 a0 a0 2f cmp %g2, 0x2f
4000c5d0: 02 80 00 22 be 4000c658 <rtems_filesystem_eval_path_next_token+0x100><== NEVER TAKEN
4000c5d4: 84 10 00 01 mov %g1, %g2
++current;
4000c5d8: 10 80 00 08 b 4000c5f8 <rtems_filesystem_eval_path_next_token+0xa0>
4000c5dc: 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)) {
4000c5e0: 80 a0 e0 5c cmp %g3, 0x5c
4000c5e4: 02 80 00 14 be 4000c634 <rtems_filesystem_eval_path_next_token+0xdc>
4000c5e8: 80 a0 e0 2f cmp %g3, 0x2f
4000c5ec: 02 80 00 13 be 4000c638 <rtems_filesystem_eval_path_next_token+0xe0>
4000c5f0: 9a 10 00 02 mov %g2, %o5
++current;
4000c5f4: 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)) {
4000c5f8: 80 a1 00 02 cmp %g4, %g2
4000c5fc: 32 bf ff f9 bne,a 4000c5e0 <rtems_filesystem_eval_path_next_token+0x88>
4000c600: c6 48 80 00 ldsb [ %g2 ], %g3
4000c604: 9a 10 00 04 mov %g4, %o5
4000c608: 86 21 00 01 sub %g4, %g1, %g3
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000c60c: 88 21 00 0d sub %g4, %o5, %g4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000c610: c4 22 00 00 st %g2, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000c614: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
4000c618: c2 22 20 08 st %g1, [ %o0 + 8 ]
ctx->tokenlen = (size_t) (current - begin);
4000c61c: 81 c3 e0 08 retl
4000c620: 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)) {
4000c624: 22 bf ff dd be,a 4000c598 <rtems_filesystem_eval_path_next_token+0x40>
4000c628: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000c62c: 10 bf ff df b 4000c5a8 <rtems_filesystem_eval_path_next_token+0x50>
4000c630: 88 21 00 01 sub %g4, %g1, %g4
4000c634: 9a 10 00 02 mov %g2, %o5
4000c638: 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);
4000c63c: 88 21 00 0d sub %g4, %o5, %g4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000c640: c4 22 00 00 st %g2, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000c644: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
4000c648: c2 22 20 08 st %g1, [ %o0 + 8 ]
ctx->tokenlen = (size_t) (current - begin);
4000c64c: 81 c3 e0 08 retl
4000c650: 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)) {
4000c654: 84 10 00 01 mov %g1, %g2
4000c658: 10 bf ff ed b 4000c60c <rtems_filesystem_eval_path_next_token+0xb4>
4000c65c: 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)) {
4000c660: 22 bf ff ce be,a 4000c598 <rtems_filesystem_eval_path_next_token+0x40>
4000c664: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000c668: 10 bf ff d0 b 4000c5a8 <rtems_filesystem_eval_path_next_token+0x50>
4000c66c: 88 21 00 01 sub %g4, %g1, %g4
4000442c <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
4000442c: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
40004430: 80 a6 a0 00 cmp %i2, 0
40004434: 02 80 00 22 be 400044bc <rtems_filesystem_eval_path_recursive+0x90><== NEVER TAKEN
40004438: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
4000443c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40004440: 80 a0 60 1f cmp %g1, 0x1f
40004444: 14 80 00 25 bg 400044d8 <rtems_filesystem_eval_path_recursive+0xac>
40004448: 01 00 00 00 nop
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
4000444c: c4 4e 40 00 ldsb [ %i1 ], %g2
const char *saved_path = ctx->path;
40004450: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
40004454: 80 a0 a0 5c cmp %g2, 0x5c
40004458: 02 80 00 1b be 400044c4 <rtems_filesystem_eval_path_recursive+0x98><== NEVER TAKEN
4000445c: f8 06 20 04 ld [ %i0 + 4 ], %i4
40004460: 80 a0 a0 2f cmp %g2, 0x2f
40004464: 02 80 00 19 be 400044c8 <rtems_filesystem_eval_path_recursive+0x9c>
40004468: 90 10 00 1d mov %i5, %o0
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
4000446c: 82 00 60 01 inc %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
40004470: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
40004474: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
40004478: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
4000447c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40004480: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40004484: c2 00 60 08 ld [ %g1 + 8 ], %g1
40004488: 9f c0 40 00 call %g1
4000448c: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
40004490: c2 07 60 04 ld [ %i5 + 4 ], %g1
40004494: 80 a0 60 00 cmp %g1, 0
40004498: 32 bf ff fa bne,a 40004480 <rtems_filesystem_eval_path_recursive+0x54>
4000449c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
400044a0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
400044a4: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
400044a8: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
400044ac: 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;
400044b0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
400044b4: 81 c7 e0 08 ret
400044b8: 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);
400044bc: 7f ff fe b4 call 40003f8c <rtems_filesystem_eval_path_error><== NOT EXECUTED
400044c0: 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);
400044c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400044c8: 7f ff ff c0 call 400043c8 <rtems_filesystem_eval_path_restart>
400044cc: 92 07 60 30 add %i5, 0x30, %o1
400044d0: 10 bf ff e7 b 4000446c <rtems_filesystem_eval_path_recursive+0x40>
400044d4: 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);
400044d8: 7f ff fe ad call 40003f8c <rtems_filesystem_eval_path_error>
400044dc: 93 e8 20 5c restore %g0, 0x5c, %o1
40004294 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
40004294: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
40004298: 40 00 32 8f call 40010cd4 <strlen>
4000429c: 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) {
400042a0: 80 a2 20 00 cmp %o0, 0
400042a4: 02 80 00 32 be 4000436c <rtems_filesystem_eval_path_start_with_parent+0xd8>
400042a8: 92 10 00 19 mov %i1, %o1
size_t i = pathlen - 1;
400042ac: 94 02 3f ff add %o0, -1, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
400042b0: c2 4e 40 0a ldsb [ %i1 + %o2 ], %g1
if (rtems_filesystem_is_delimiter(path [i])) {
400042b4: 80 a0 60 5c cmp %g1, 0x5c
400042b8: 02 80 00 2a be 40004360 <rtems_filesystem_eval_path_start_with_parent+0xcc><== NEVER TAKEN
400042bc: 80 a0 60 2f cmp %g1, 0x2f
400042c0: 12 80 00 08 bne 400042e0 <rtems_filesystem_eval_path_start_with_parent+0x4c>
400042c4: 80 a2 a0 00 cmp %o2, 0
400042c8: 10 80 00 27 b 40004364 <rtems_filesystem_eval_path_start_with_parent+0xd0>
400042cc: 94 10 00 08 mov %o0, %o2
400042d0: 02 80 00 0b be 400042fc <rtems_filesystem_eval_path_start_with_parent+0x68>
400042d4: 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;
400042d8: 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) {
400042dc: 80 a2 a0 00 cmp %o2, 0
400042e0: 02 80 00 1a be 40004348 <rtems_filesystem_eval_path_start_with_parent+0xb4>
400042e4: 82 02 bf ff add %o2, -1, %g1
400042e8: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
400042ec: 80 a0 a0 5c cmp %g2, 0x5c
400042f0: 12 bf ff f8 bne 400042d0 <rtems_filesystem_eval_path_start_with_parent+0x3c><== ALWAYS TAKEN
400042f4: 80 a0 a0 2f cmp %g2, 0x2f
400042f8: a0 22 00 0a sub %o0, %o2, %l0 <== NOT EXECUTED
parentpath = ".";
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
400042fc: 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;
40004300: 92 10 00 19 mov %i1, %o1
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
40004304: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004308: da 00 63 ec ld [ %g1 + 0x3ec ], %o5 ! 4001e3ec <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
4000430c: 96 10 00 1c mov %i4, %o3
40004310: 98 03 60 04 add %o5, 4, %o4
40004314: 7f ff ff 7a call 400040fc <eval_path_start>
40004318: 90 10 00 18 mov %i0, %o0
4000431c: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
40004320: 40 00 1e 7a call 4000bd08 <rtems_filesystem_location_clone>
40004324: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
40004328: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
4000432c: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
40004330: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
40004334: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
40004338: 7f ff ff 54 call 40004088 <rtems_filesystem_eval_path_continue>
4000433c: b0 06 20 18 add %i0, 0x18, %i0
40004340: 81 c7 e0 08 ret
40004344: 81 e8 00 00 restore
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
40004348: 13 10 00 73 sethi %hi(0x4001cc00), %o1
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
4000434c: a0 10 00 08 mov %o0, %l0
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
name = path;
40004350: ba 10 00 19 mov %i1, %i5
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
40004354: 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 = ".";
40004358: 10 bf ff eb b 40004304 <rtems_filesystem_eval_path_start_with_parent+0x70>
4000435c: 92 12 63 38 or %o1, 0x338, %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])) {
40004360: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40004364: 10 bf ff e6 b 400042fc <rtems_filesystem_eval_path_start_with_parent+0x68>
40004368: 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;
4000436c: 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;
40004370: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
40004374: 10 bf ff e4 b 40004304 <rtems_filesystem_eval_path_start_with_parent+0x70>
40004378: 94 10 20 00 clr %o2
4000c06c <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000c06c: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
4000c070: f0 27 bf f8 st %i0, [ %fp + -8 ]
4000c074: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000c078: 82 10 00 18 mov %i0, %g1
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000c07c: 80 a0 60 00 cmp %g1, 0
4000c080: 02 80 00 07 be 4000c09c <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
4000c084: b0 10 20 00 clr %i0
rtems_filesystem_iterate( find_handler, &fa );
4000c088: 92 07 bf f8 add %fp, -8, %o1
4000c08c: 11 10 00 2f sethi %hi(0x4000bc00), %o0
4000c090: 7f ff ff c9 call 4000bfb4 <rtems_filesystem_iterate>
4000c094: 90 12 23 80 or %o0, 0x380, %o0 ! 4000bf80 <find_handler>
4000c098: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
4000c09c: 81 c7 e0 08 ret
4000c0a0: 81 e8 00 00 restore
400047b4 <rtems_filesystem_global_location_obtain>:
}
rtems_filesystem_global_location_t *rtems_filesystem_global_location_obtain(
rtems_filesystem_global_location_t *const *global_loc_ptr
)
{
400047b4: 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) {
400047b8: 37 10 00 7a sethi %hi(0x4001e800), %i3
400047bc: c2 06 e2 a8 ld [ %i3 + 0x2a8 ], %g1 ! 4001eaa8 <deferred_released_global_locations>
400047c0: 80 a0 60 00 cmp %g1, 0
400047c4: 02 80 00 1e be 4000483c <rtems_filesystem_global_location_obtain+0x88>
400047c8: 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;
400047cc: 39 10 00 7b sethi %hi(0x4001ec00), %i4
400047d0: c2 07 22 c0 ld [ %i4 + 0x2c0 ], %g1 ! 4001eec0 <_Thread_Dispatch_disable_level>
++level;
400047d4: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
400047d8: c2 27 22 c0 st %g1, [ %i4 + 0x2c0 ]
do {
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
400047dc: fa 06 e2 a8 ld [ %i3 + 0x2a8 ], %i5
if (current != NULL) {
400047e0: 80 a7 60 00 cmp %i5, 0
400047e4: 02 80 00 14 be 40004834 <rtems_filesystem_global_location_obtain+0x80><== NEVER TAKEN
400047e8: 01 00 00 00 nop
400047ec: b6 16 e2 a8 or %i3, 0x2a8, %i3
400047f0: b8 17 22 c0 or %i4, 0x2c0, %i4
deferred_released_global_locations = current->deferred_released_next;
400047f4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
count = current->deferred_released_count;
400047f8: 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;
400047fc: c2 26 c0 00 st %g1, [ %i3 ]
count = current->deferred_released_count;
current->deferred_released_next = NULL;
40004800: c0 27 60 1c clr [ %i5 + 0x1c ]
current->deferred_released_count = 0;
}
_Thread_Enable_dispatch();
40004804: 40 00 15 b1 call 40009ec8 <_Thread_Enable_dispatch>
40004808: c0 27 60 20 clr [ %i5 + 0x20 ]
if (current != NULL) {
release_with_count(current, count);
4000480c: 90 10 00 1d mov %i5, %o0
40004810: 7f ff ff 9e call 40004688 <release_with_count>
40004814: 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;
40004818: c2 07 00 00 ld [ %i4 ], %g1
++level;
4000481c: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
40004820: c2 27 00 00 st %g1, [ %i4 ]
do {
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
40004824: fa 06 c0 00 ld [ %i3 ], %i5
if (current != NULL) {
40004828: 80 a7 60 00 cmp %i5, 0
4000482c: 32 bf ff f3 bne,a 400047f8 <rtems_filesystem_global_location_obtain+0x44><== NEVER TAKEN
40004830: 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();
40004834: 40 00 15 a5 call 40009ec8 <_Thread_Enable_dispatch>
40004838: 01 00 00 00 nop
if (deferred_released_global_locations != NULL) {
deferred_release();
}
rtems_filesystem_mt_entry_lock(lock_context);
4000483c: 7f ff f6 1a call 400020a4 <sparc_disable_interrupts>
40004840: 01 00 00 00 nop
40004844: ba 10 00 08 mov %o0, %i5
global_loc = *global_loc_ptr;
40004848: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
4000484c: 80 a6 20 00 cmp %i0, 0
40004850: 02 80 00 07 be 4000486c <rtems_filesystem_global_location_obtain+0xb8>
40004854: 01 00 00 00 nop
40004858: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000485c: c2 08 60 28 ldub [ %g1 + 0x28 ], %g1
40004860: 80 a0 60 00 cmp %g1, 0
40004864: 32 80 00 08 bne,a 40004884 <rtems_filesystem_global_location_obtain+0xd0>
40004868: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
global_loc = &rtems_filesystem_global_location_null;
errno = ENXIO;
4000486c: 40 00 2b b5 call 4000f740 <__errno>
40004870: 31 10 00 79 sethi %hi(0x4001e400), %i0
40004874: 82 10 20 06 mov 6, %g1
40004878: 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;
4000487c: b0 16 20 1c or %i0, 0x1c, %i0
errno = ENXIO;
}
++global_loc->reference_count;
40004880: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40004884: 82 00 60 01 inc %g1
40004888: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
rtems_filesystem_mt_entry_unlock(lock_context);
4000488c: 7f ff f6 0a call 400020b4 <sparc_enable_interrupts>
40004890: 90 10 00 1d mov %i5, %o0
40004894: 81 c7 e0 08 ret
40004898: 81 e8 00 00 restore
40002d04 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40002d04: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40002d08: 05 10 00 71 sethi %hi(0x4001c400), %g2
40002d0c: 82 10 a0 64 or %g2, 0x64, %g1 ! 4001c464 <rtems_filesystem_root_configuration>
40002d10: d0 00 a0 64 ld [ %g2 + 0x64 ], %o0
40002d14: d2 00 60 04 ld [ %g1 + 4 ], %o1
40002d18: d4 00 60 08 ld [ %g1 + 8 ], %o2
40002d1c: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40002d20: 40 00 02 22 call 400035a8 <mount>
40002d24: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40002d28: 80 a2 20 00 cmp %o0, 0
40002d2c: 12 80 00 0a bne 40002d54 <rtems_filesystem_initialize+0x50><== NEVER TAKEN
40002d30: 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);
40002d34: 11 10 00 72 sethi %hi(0x4001c800), %o0
40002d38: 40 00 01 d3 call 40003484 <mkdir>
40002d3c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 4001c9c8 <IMFS_node_control_default+0x58>
if ( rv != 0 )
40002d40: 80 a2 20 00 cmp %o0, 0
40002d44: 12 80 00 07 bne 40002d60 <rtems_filesystem_initialize+0x5c><== NEVER TAKEN
40002d48: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
40002d4c: 81 c7 e0 08 ret
40002d50: 81 e8 00 00 restore
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0002 );
40002d54: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
40002d58: 40 00 13 72 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002d5c: 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 );
40002d60: 40 00 13 70 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002d64: 90 12 20 03 or %o0, 3, %o0 <== NOT EXECUTED
4000bfb4 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
4000bfb4: 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 ) {
4000bfb8: 3b 10 00 71 sethi %hi(0x4001c400), %i5
4000bfbc: c2 07 60 78 ld [ %i5 + 0x78 ], %g1 ! 4001c478 <rtems_filesystem_table>
4000bfc0: 80 a0 60 00 cmp %g1, 0
4000bfc4: 12 80 00 06 bne 4000bfdc <rtems_filesystem_iterate+0x28> <== ALWAYS TAKEN
4000bfc8: ba 17 60 78 or %i5, 0x78, %i5
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000bfcc: 10 80 00 0e b 4000c004 <rtems_filesystem_iterate+0x50> <== NOT EXECUTED
4000bfd0: 35 10 00 7b sethi %hi(0x4001ec00), %i2 <== NOT EXECUTED
4000bfd4: 12 80 00 24 bne 4000c064 <rtems_filesystem_iterate+0xb0>
4000bfd8: 01 00 00 00 nop
stop = (*routine)( table_entry, routine_arg );
4000bfdc: 90 10 00 1d mov %i5, %o0
4000bfe0: 9f c6 00 00 call %i0
4000bfe4: 92 10 00 19 mov %i1, %o1
++table_entry;
4000bfe8: 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 ) {
4000bfec: c2 07 40 00 ld [ %i5 ], %g1
4000bff0: 80 a0 60 00 cmp %g1, 0
4000bff4: 12 bf ff f8 bne 4000bfd4 <rtems_filesystem_iterate+0x20>
4000bff8: b8 8a 20 ff andcc %o0, 0xff, %i4
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
4000bffc: 12 80 00 1a bne 4000c064 <rtems_filesystem_iterate+0xb0>
4000c000: 35 10 00 7b sethi %hi(0x4001ec00), %i2
4000c004: d0 06 a1 38 ld [ %i2 + 0x138 ], %o0 ! 4001ed38 <rtems_libio_semaphore>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000c008: 37 10 00 79 sethi %hi(0x4001e400), %i3
4000c00c: 92 10 20 00 clr %o1
4000c010: 7f ff ec df call 4000738c <rtems_semaphore_obtain>
4000c014: 94 10 20 00 clr %o2
4000c018: fa 06 e0 9c ld [ %i3 + 0x9c ], %i5
4000c01c: b6 16 e0 9c or %i3, 0x9c, %i3
rtems_libio_lock();
for (
4000c020: b6 06 e0 04 add %i3, 4, %i3
4000c024: 80 a7 40 1b cmp %i5, %i3
4000c028: 12 80 00 05 bne 4000c03c <rtems_filesystem_iterate+0x88>
4000c02c: b8 10 20 00 clr %i4
4000c030: 30 80 00 0b b,a 4000c05c <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
4000c034: 12 80 00 0a bne 4000c05c <rtems_filesystem_iterate+0xa8> <== NEVER TAKEN
4000c038: 01 00 00 00 nop
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
4000c03c: 90 07 60 08 add %i5, 8, %o0
4000c040: 9f c6 00 00 call %i0
4000c044: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000c048: fa 07 40 00 ld [ %i5 ], %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
4000c04c: 80 a7 40 1b cmp %i5, %i3
4000c050: 12 bf ff f9 bne 4000c034 <rtems_filesystem_iterate+0x80>
4000c054: b8 8a 20 ff andcc %o0, 0xff, %i4
4000c058: b8 0a 20 ff and %o0, 0xff, %i4
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000c05c: 7f ff ed 1b call 400074c8 <rtems_semaphore_release>
4000c060: d0 06 a1 38 ld [ %i2 + 0x138 ], %o0
}
rtems_libio_unlock();
}
return stop;
}
4000c064: 81 c7 e0 08 ret
4000c068: 91 e8 00 1c restore %g0, %i4, %o0
4000bd08 <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000bd08: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000bd0c: 92 10 00 19 mov %i1, %o1
4000bd10: 7f ff e1 f4 call 400044e0 <rtems_filesystem_location_copy>
4000bd14: 90 10 00 18 mov %i0, %o0
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000bd18: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000bd1c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000bd20: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
4000bd24: 9f c0 40 00 call %g1
4000bd28: b0 10 00 08 mov %o0, %i0
if ( rv != 0 ) {
4000bd2c: 80 a2 20 00 cmp %o0, 0
4000bd30: 12 80 00 04 bne 4000bd40 <rtems_filesystem_location_clone+0x38><== NEVER TAKEN
4000bd34: 90 10 00 18 mov %i0, %o0
4000bd38: 81 c7 e0 08 ret
4000bd3c: 81 e8 00 00 restore
rtems_filesystem_location_remove_from_mt_entry( clone );
4000bd40: 7f ff e2 24 call 400045d0 <rtems_filesystem_location_remove_from_mt_entry><== NOT EXECUTED
4000bd44: 33 10 00 79 sethi %hi(0x4001e400), %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(
4000bd48: 7f ff e1 e6 call 400044e0 <rtems_filesystem_location_copy><== NOT EXECUTED
4000bd4c: 93 ee 60 1c restore %i1, 0x1c, %o1 <== NOT EXECUTED
400045d0 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
400045d0: 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);
400045d4: 7f ff f6 b4 call 400020a4 <sparc_disable_interrupts>
400045d8: 01 00 00 00 nop
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
400045dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400045e0: c6 06 00 00 ld [ %i0 ], %g3
previous = the_node->previous;
400045e4: 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;
400045e8: c8 08 60 28 ldub [ %g1 + 0x28 ], %g4
next->previous = previous;
400045ec: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
400045f0: c6 20 80 00 st %g3, [ %g2 ]
400045f4: 80 a1 20 00 cmp %g4, 0
400045f8: 12 80 00 07 bne 40004614 <rtems_filesystem_location_remove_from_mt_entry+0x44>
400045fc: 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 )
40004600: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
40004604: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
40004608: 80 a0 c0 02 cmp %g3, %g2
4000460c: 22 80 00 0b be,a 40004638 <rtems_filesystem_location_remove_from_mt_entry+0x68>
40004610: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
rtems_filesystem_mt_entry_unlock(lock_context);
40004614: 7f ff f6 a8 call 400020b4 <sparc_enable_interrupts>
40004618: 01 00 00 00 nop
if (do_unmount) {
4000461c: 80 8f 60 ff btst 0xff, %i5
40004620: 32 80 00 04 bne,a 40004630 <rtems_filesystem_location_remove_from_mt_entry+0x60><== NEVER TAKEN
40004624: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
40004628: 81 c7 e0 08 ret
4000462c: 81 e8 00 00 restore
rtems_filesystem_do_unmount(loc->mt_entry);
40004630: 7f ff ff c8 call 40004550 <rtems_filesystem_do_unmount> <== NOT EXECUTED
40004634: 81 e8 00 00 restore <== NOT EXECUTED
&& mt_entry->mt_fs_root->reference_count == 1;
40004638: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2
4000463c: 80 a0 a0 01 cmp %g2, 1
40004640: 12 bf ff f5 bne 40004614 <rtems_filesystem_location_remove_from_mt_entry+0x44><== ALWAYS TAKEN
40004644: 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 );
40004648: 86 00 60 18 add %g1, 0x18, %g3 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
4000464c: 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;
40004650: c6 20 60 14 st %g3, [ %g1 + 0x14 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
40004654: 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
40004658: 10 bf ff ef b 40004614 <rtems_filesystem_location_remove_from_mt_entry+0x44><== NOT EXECUTED
4000465c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
4000489c <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
4000489c: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
400048a0: 7f ff fa bc call 40003390 <malloc>
400048a4: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
400048a8: ba 92 20 00 orcc %o0, 0, %i5
400048ac: 02 80 00 0c be 400048dc <rtems_filesystem_location_transform_to_global+0x40><== NEVER TAKEN
400048b0: 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);
400048b4: 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;
400048b8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
400048bc: c0 27 60 1c clr [ %i5 + 0x1c ]
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
400048c0: 7f ff ff 08 call 400044e0 <rtems_filesystem_location_copy>
400048c4: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_remove_from_mt_entry(loc);
400048c8: 90 10 00 18 mov %i0, %o0
400048cc: 7f ff ff 41 call 400045d0 <rtems_filesystem_location_remove_from_mt_entry>
400048d0: b0 10 00 1d mov %i5, %i0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
400048d4: 81 c7 e0 08 ret
400048d8: 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);
400048dc: 40 00 1d 1d call 4000bd50 <rtems_filesystem_location_free><== NOT EXECUTED
400048e0: 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 );
400048e4: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
400048e8: 7f ff ff b3 call 400047b4 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
400048ec: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
400048f0: 40 00 2b 94 call 4000f740 <__errno> <== NOT EXECUTED
400048f4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
400048f8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
400048fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
40004900: 81 c7 e0 08 ret <== NOT EXECUTED
40004904: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
400034a0 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
400034a0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
400034a4: 03 10 00 78 sethi %hi(0x4001e000), %g1
400034a8: c2 00 63 ec ld [ %g1 + 0x3ec ], %g1 ! 4001e3ec <rtems_current_user_env>
switch (mode & S_IFMT) {
400034ac: 05 00 00 10 sethi %hi(0x4000), %g2
dev_t dev
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
400034b0: d6 00 60 08 ld [ %g1 + 8 ], %o3
switch (mode & S_IFMT) {
400034b4: 03 00 00 3c sethi %hi(0xf000), %g1
dev_t dev
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
400034b8: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
400034bc: 82 0a c0 01 and %o3, %g1, %g1
400034c0: 80 a0 40 02 cmp %g1, %g2
400034c4: 22 80 00 18 be,a 40003524 <rtems_filesystem_mknod+0x84>
400034c8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400034cc: 08 80 00 0f bleu 40003508 <rtems_filesystem_mknod+0x68>
400034d0: 05 00 00 04 sethi %hi(0x1000), %g2
400034d4: 05 00 00 18 sethi %hi(0x6000), %g2
400034d8: 80 a0 40 02 cmp %g1, %g2
400034dc: 02 80 00 11 be 40003520 <rtems_filesystem_mknod+0x80>
400034e0: 05 00 00 20 sethi %hi(0x8000), %g2
400034e4: 80 a0 40 02 cmp %g1, %g2
400034e8: 22 80 00 0f be,a 40003524 <rtems_filesystem_mknod+0x84> <== ALWAYS TAKEN
400034ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
case S_IFDIR:
case S_IFIFO:
case S_IFREG:
break;
default:
errno = EINVAL;
400034f0: 40 00 30 94 call 4000f740 <__errno>
400034f4: b0 10 3f ff mov -1, %i0
400034f8: 82 10 20 16 mov 0x16, %g1
400034fc: c2 22 00 00 st %g1, [ %o0 ]
40003500: 81 c7 e0 08 ret
40003504: 81 e8 00 00 restore
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
40003508: 80 a0 40 02 cmp %g1, %g2
4000350c: 02 80 00 05 be 40003520 <rtems_filesystem_mknod+0x80>
40003510: 05 00 00 08 sethi %hi(0x2000), %g2
40003514: 80 a0 40 02 cmp %g1, %g2
40003518: 12 bf ff f6 bne 400034f0 <rtems_filesystem_mknod+0x50>
4000351c: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40003520: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
40003524: 90 10 00 18 mov %i0, %o0
40003528: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000352c: 92 10 00 19 mov %i1, %o1
40003530: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40003534: 94 10 00 1a mov %i2, %o2
40003538: 98 10 00 1c mov %i4, %o4
4000353c: 9f c0 40 00 call %g1
40003540: 9a 10 00 1d mov %i5, %o5
}
return rv;
}
40003544: 81 c7 e0 08 ret
40003548: 91 e8 00 08 restore %g0, %o0, %o0
4000c170 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
4000c170: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_node *node = NULL;
if ( type == NULL ) {
4000c174: 80 a6 20 00 cmp %i0, 0
4000c178: 02 80 00 29 be 4000c21c <rtems_filesystem_unregister+0xac>
4000c17c: 37 10 00 7b sethi %hi(0x4001ec00), %i3
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000c180: d0 06 e1 38 ld [ %i3 + 0x138 ], %o0 ! 4001ed38 <rtems_libio_semaphore>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000c184: 39 10 00 79 sethi %hi(0x4001e400), %i4
4000c188: 92 10 20 00 clr %o1
4000c18c: 7f ff ec 80 call 4000738c <rtems_semaphore_obtain>
4000c190: 94 10 20 00 clr %o2
4000c194: fa 07 20 9c ld [ %i4 + 0x9c ], %i5
4000c198: b8 17 20 9c or %i4, 0x9c, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
4000c19c: b8 07 20 04 add %i4, 4, %i4
4000c1a0: 80 a7 40 1c cmp %i5, %i4
4000c1a4: 32 80 00 08 bne,a 4000c1c4 <rtems_filesystem_unregister+0x54>
4000c1a8: d0 07 60 08 ld [ %i5 + 8 ], %o0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000c1ac: 10 80 00 14 b 4000c1fc <rtems_filesystem_unregister+0x8c>
4000c1b0: d0 06 e1 38 ld [ %i3 + 0x138 ], %o0
4000c1b4: 80 a7 40 1c cmp %i5, %i4
4000c1b8: 02 80 00 11 be 4000c1fc <rtems_filesystem_unregister+0x8c><== ALWAYS TAKEN
4000c1bc: d0 06 e1 38 ld [ %i3 + 0x138 ], %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 ) {
4000c1c0: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
4000c1c4: 40 00 10 f9 call 400105a8 <strcmp>
4000c1c8: 92 10 00 18 mov %i0, %o1
4000c1cc: 80 a2 20 00 cmp %o0, 0
4000c1d0: 32 bf ff f9 bne,a 4000c1b4 <rtems_filesystem_unregister+0x44>
4000c1d4: fa 07 40 00 ld [ %i5 ], %i5
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4000c1d8: 40 00 04 40 call 4000d2d8 <_Chain_Extract>
4000c1dc: 90 10 00 1d mov %i5, %o0
rtems_chain_extract( node );
free( fsn );
4000c1e0: 7f ff db 92 call 40003028 <free>
4000c1e4: 90 10 00 1d mov %i5, %o0
4000c1e8: d0 06 e1 38 ld [ %i3 + 0x138 ], %o0
4000c1ec: 7f ff ec b7 call 400074c8 <rtems_semaphore_release>
4000c1f0: b0 10 20 00 clr %i0
4000c1f4: 81 c7 e0 08 ret
4000c1f8: 81 e8 00 00 restore
4000c1fc: 7f ff ec b3 call 400074c8 <rtems_semaphore_release>
4000c200: b0 10 3f ff mov -1, %i0
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
4000c204: 40 00 0d 4f call 4000f740 <__errno>
4000c208: 01 00 00 00 nop
4000c20c: 82 10 20 02 mov 2, %g1 ! 2 <PROM_START+0x2>
4000c210: c2 22 00 00 st %g1, [ %o0 ]
}
4000c214: 81 c7 e0 08 ret
4000c218: 81 e8 00 00 restore
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
4000c21c: 40 00 0d 49 call 4000f740 <__errno>
4000c220: b0 10 3f ff mov -1, %i0
4000c224: 82 10 20 16 mov 0x16, %g1
4000c228: c2 22 00 00 st %g1, [ %o0 ]
4000c22c: 81 c7 e0 08 ret
4000c230: 81 e8 00 00 restore
400035f0 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
400035f0: 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 ) );
400035f4: 40 00 01 0c call 40003a24 <malloc>
400035f8: 90 10 20 08 mov 8, %o0
*key = new_key;
new_key->val = NULL;
400035fc: 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;
40003600: 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 ) );
40003604: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
new_key->dtor = dtor;
40003608: 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 );
4000360c: 92 10 00 1d mov %i5, %o1
40003610: 90 10 20 00 clr %o0
40003614: 94 10 00 19 mov %i1, %o2
40003618: 40 00 12 84 call 40008028 <rtems_task_variable_add>
4000361c: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
40003620: 80 a2 20 00 cmp %o0, 0
40003624: 02 80 00 04 be 40003634 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
40003628: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
4000362c: 7f ff ff 81 call 40003430 <free> <== NOT EXECUTED
40003630: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
40003634: 81 c7 e0 08 ret
40003638: 81 e8 00 00 restore
40003648 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
40003648: 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 );
4000364c: 90 10 20 00 clr %o0
40003650: 40 00 12 a8 call 400080f0 <rtems_task_variable_delete>
40003654: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
40003658: 80 a2 20 00 cmp %o0, 0
4000365c: 12 80 00 06 bne 40003674 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
40003660: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
40003664: 02 80 00 04 be 40003674 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
40003668: 01 00 00 00 nop
4000366c: 7f ff ff 71 call 40003430 <free>
40003670: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
40003674: 81 c7 e0 08 ret
40003678: 91 e8 20 00 restore %g0, 0, %o0
40003580 <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))
{
40003580: 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 ) {
40003584: c2 06 00 00 ld [ %i0 ], %g1
40003588: 80 a0 60 00 cmp %g1, 0
4000358c: 02 80 00 04 be 4000359c <rtems_gxx_once+0x1c>
40003590: 92 10 21 00 mov 0x100, %o1
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
40003594: 81 c7 e0 08 ret
40003598: 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);
4000359c: 94 07 bf fc add %fp, -4, %o2
400035a0: 40 00 12 18 call 40007e00 <rtems_task_mode>
400035a4: 90 10 21 00 mov 0x100, %o0
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
400035a8: c2 06 00 00 ld [ %i0 ], %g1
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
400035ac: d0 07 bf fc ld [ %fp + -4 ], %o0
400035b0: 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 ) {
400035b4: 80 a0 60 00 cmp %g1, 0
400035b8: 12 80 00 0a bne 400035e0 <rtems_gxx_once+0x60> <== NEVER TAKEN
400035bc: 94 07 bf fc add %fp, -4, %o2
*(volatile __gthread_once_t *)once = 1;
400035c0: 82 10 20 01 mov 1, %g1
400035c4: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
400035c8: 40 00 12 0e call 40007e00 <rtems_task_mode>
400035cc: b0 10 20 00 clr %i0
if ( o == 0 )
(*func)();
400035d0: 9f c6 40 00 call %i1
400035d4: 01 00 00 00 nop
}
return 0;
}
400035d8: 81 c7 e0 08 ret
400035dc: 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);
400035e0: 40 00 12 08 call 40007e00 <rtems_task_mode> <== NOT EXECUTED
400035e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
400035e8: 81 c7 e0 08 ret <== NOT EXECUTED
400035ec: 81 e8 00 00 restore <== NOT EXECUTED
400036e4 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
400036e4: 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 );
400036e8: d4 06 20 04 ld [ %i0 + 4 ], %o2
400036ec: 90 10 20 00 clr %o0
400036f0: 40 00 12 4e call 40008028 <rtems_task_variable_add>
400036f4: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
400036f8: 80 a2 20 00 cmp %o0, 0
400036fc: 12 80 00 05 bne 40003710 <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
40003700: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
40003704: f2 26 00 00 st %i1, [ %i0 ]
return 0;
40003708: 81 c7 e0 08 ret
4000370c: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
40003710: 81 c7 e0 08 ret <== NOT EXECUTED
40003714: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400085f4 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
400085f4: 9d e3 bf a0 save %sp, -96, %sp
if (
400085f8: 03 10 00 99 sethi %hi(0x40026400), %g1
400085fc: c2 00 63 08 ld [ %g1 + 0x308 ], %g1 ! 40026708 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40008600: ba 10 00 18 mov %i0, %i5
40008604: b8 10 00 19 mov %i1, %i4
if (
40008608: 80 a0 60 03 cmp %g1, 3
4000860c: 02 80 00 08 be 4000862c <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
40008610: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
40008614: 7f ff fb d4 call 40007564 <malloc_deferred_frees_process>
40008618: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
4000861c: 03 10 00 93 sethi %hi(0x40024c00), %g1
40008620: f0 00 61 b4 ld [ %g1 + 0x1b4 ], %i0 ! 40024db4 <RTEMS_Malloc_Heap>
40008624: 40 00 19 6f call 4000ebe0 <_Protected_heap_Allocate_aligned_with_boundary>
40008628: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
4000862c: 7f ff fb c1 call 40007530 <malloc_is_system_state_OK>
40008630: 01 00 00 00 nop
40008634: 80 8a 20 ff btst 0xff, %o0
40008638: 12 bf ff f7 bne 40008614 <rtems_heap_allocate_aligned_with_boundary+0x20>
4000863c: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
40008640: 81 c7 e0 08 ret
40008644: 81 e8 00 00 restore
40003be8 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
40003be8: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
40003bec: 03 10 00 5b sethi %hi(0x40016c00), %g1
40003bf0: f8 00 60 90 ld [ %g1 + 0x90 ], %i4 ! 40016c90 <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_size % sbrk_amount;
40003bf4: 90 10 00 19 mov %i1, %o0
40003bf8: 92 10 00 1c mov %i4, %o1
40003bfc: 40 00 3c f4 call 40012fcc <.rem>
40003c00: ba 10 00 19 mov %i1, %i5
void *return_this = NULL;
if ( misaligned != 0 ) {
40003c04: 80 a2 20 00 cmp %o0, 0
40003c08: 02 80 00 05 be 40003c1c <rtems_heap_extend_via_sbrk+0x34>
40003c0c: 80 a7 60 00 cmp %i5, 0
sbrk_size += sbrk_amount - misaligned;
40003c10: ba 27 00 08 sub %i4, %o0, %i5
40003c14: ba 06 40 1d add %i1, %i5, %i5
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
40003c18: 80 a7 60 00 cmp %i5, 0
40003c1c: 04 80 00 17 ble 40003c78 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40003c20: 80 a7 20 00 cmp %i4, 0
40003c24: 04 80 00 15 ble 40003c78 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40003c28: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
40003c2c: 7f ff f6 2d call 400014e0 <sbrk>
40003c30: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
40003c34: 80 a2 3f ff cmp %o0, -1
40003c38: 02 80 00 10 be 40003c78 <rtems_heap_extend_via_sbrk+0x90>
40003c3c: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
40003c40: 90 10 00 18 mov %i0, %o0
40003c44: 40 00 14 a5 call 40008ed8 <_Protected_heap_Extend>
40003c48: 94 10 00 1d mov %i5, %o2
if ( ok ) {
40003c4c: 80 8a 20 ff btst 0xff, %o0
40003c50: 02 80 00 08 be 40003c70 <rtems_heap_extend_via_sbrk+0x88>
40003c54: 03 10 00 5b sethi %hi(0x40016c00), %g1
MSBUMP( space_available, sbrk_size );
40003c58: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40016c60 <rtems_malloc_statistics>
40003c5c: b4 10 20 00 clr %i2
40003c60: ba 07 40 02 add %i5, %g2, %i5
40003c64: fa 20 60 60 st %i5, [ %g1 + 0x60 ]
40003c68: 40 00 14 8e call 40008ea0 <_Protected_heap_Allocate_aligned_with_boundary>
40003c6c: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( heap, alloc_size );
} else {
sbrk( -sbrk_size );
40003c70: 7f ff f6 1c call 400014e0 <sbrk>
40003c74: 90 20 00 1d neg %i5, %o0
}
}
}
return return_this;
}
40003c78: 81 c7 e0 08 ret
40003c7c: 91 e8 20 00 restore %g0, 0, %o0
40003ee0 <rtems_heap_null_extend>:
Heap_Control *heap __attribute__((unused)),
size_t alloc_size __attribute__((unused))
)
{
return NULL;
}
40003ee0: 81 c3 e0 08 retl
40003ee4: 90 10 20 00 clr %o0
400049c8 <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
400049c8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400049cc: 7f ff fe bb call 400044b8 <partition_table_free> <== NOT EXECUTED
400049d0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400049d4 <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 );
400049d4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400049d8: 7f ff ff 89 call 400047fc <partition_table_get> <== NOT EXECUTED
400049dc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400049e0 <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)
{
400049e0: 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));
400049e4: 90 10 20 01 mov 1, %o0
400049e8: 92 10 21 28 mov 0x128, %o1
400049ec: 40 00 02 2c call 4000529c <calloc>
400049f0: b2 10 00 18 mov %i0, %i1
if (disk_desc == NULL)
{
return RTEMS_NO_MEMORY;
400049f4: 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)
400049f8: 80 a2 20 00 cmp %o0, 0
400049fc: 02 80 00 33 be 40004ac8 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
40004a00: b4 10 00 08 mov %o0, %i2
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
40004a04: 90 10 00 19 mov %i1, %o0
40004a08: 7f ff ff 7d call 400047fc <partition_table_get>
40004a0c: 92 10 00 1a mov %i2, %o1
if (rc != RTEMS_SUCCESSFUL)
40004a10: b0 92 20 00 orcc %o0, 0, %i0
40004a14: 12 80 00 36 bne 40004aec <rtems_ide_part_table_initialize+0x10c><== NEVER TAKEN
40004a18: 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++)
40004a1c: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40004a20: b6 07 bf f0 add %fp, -16, %i3
40004a24: 21 10 00 95 sethi %hi(0x40025400), %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);
40004a28: 27 10 00 95 sethi %hi(0x40025400), %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);
40004a2c: a0 14 22 48 or %l0, 0x248, %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++)
40004a30: 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);
40004a34: 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);
40004a38: 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);
40004a3c: 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)
40004a40: 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);
40004a44: 29 10 00 99 sethi %hi(0x40026400), %l4
40004a48: a6 14 e2 50 or %l3, 0x250, %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);
40004a4c: 92 10 00 10 mov %l0, %o1
40004a50: 94 10 00 19 mov %i1, %o2
40004a54: 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++)
40004a58: 16 80 00 1a bge 40004ac0 <rtems_ide_part_table_initialize+0xe0><== NEVER TAKEN
40004a5c: 96 10 00 1d mov %i5, %o3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40004a60: 40 00 46 0b call 4001628c <sprintf>
40004a64: 01 00 00 00 nop
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
40004a68: c2 07 00 00 ld [ %i4 ], %g1
if (part_desc == NULL)
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40004a6c: 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)
40004a70: 80 a0 60 00 cmp %g1, 0
40004a74: 02 80 00 0a be 40004a9c <rtems_ide_part_table_initialize+0xbc>
40004a78: 92 07 40 11 add %i5, %l1, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40004a7c: d8 00 60 04 ld [ %g1 + 4 ], %o4
40004a80: da 00 60 08 ld [ %g1 + 8 ], %o5
40004a84: d4 1e 80 00 ldd [ %i2 ], %o2
40004a88: 7f ff fd 47 call 40003fa4 <rtems_disk_create_log>
40004a8c: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
40004a90: 96 92 20 00 orcc %o0, 0, %o3
40004a94: 12 80 00 0f bne 40004ad0 <rtems_ide_part_table_initialize+0xf0><== NEVER TAKEN
40004a98: c2 05 23 c0 ld [ %l4 + 0x3c0 ], %g1
40004a9c: 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++)
40004aa0: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40004aa4: 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++)
40004aa8: 80 a7 40 01 cmp %i5, %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40004aac: 94 10 00 19 mov %i1, %o2
40004ab0: ba 07 60 01 inc %i5
40004ab4: 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++)
40004ab8: 06 bf ff ea bl 40004a60 <rtems_ide_part_table_initialize+0x80>
40004abc: 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);
40004ac0: 7f ff fe 7e call 400044b8 <partition_table_free>
40004ac4: 90 10 00 1a mov %i2, %o0
return RTEMS_SUCCESSFUL;
}
40004ac8: 81 c7 e0 08 ret
40004acc: 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);
40004ad0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40004ad4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40004ad8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40004adc: 40 00 43 dd call 40015a50 <fprintf> <== NOT EXECUTED
40004ae0: 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++)
40004ae4: 10 bf ff f0 b 40004aa4 <rtems_ide_part_table_initialize+0xc4><== NOT EXECUTED
40004ae8: 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);
40004aec: 40 00 02 23 call 40005378 <free> <== NOT EXECUTED
40004af0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40004af4: 81 c7 e0 08 ret <== NOT EXECUTED
40004af8: 81 e8 00 00 restore <== NOT EXECUTED
40008e6c <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
)
{
40008e6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
40008e70: 03 10 00 6d sethi %hi(0x4001b400), %g1
40008e74: c4 00 63 e8 ld [ %g1 + 0x3e8 ], %g2 ! 4001b7e8 <_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
)
{
40008e78: ba 10 00 18 mov %i0, %i5
rtems_device_major_number major_limit = _IO_Number_of_drivers;
40008e7c: 03 10 00 6f sethi %hi(0x4001bc00), %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
)
{
40008e80: 86 10 00 19 mov %i1, %g3
rtems_device_major_number major_limit = _IO_Number_of_drivers;
40008e84: c8 00 60 28 ld [ %g1 + 0x28 ], %g4
if ( rtems_interrupt_is_in_progress() )
40008e88: 80 a0 a0 00 cmp %g2, 0
40008e8c: 12 80 00 1f bne 40008f08 <rtems_io_register_driver+0x9c>
40008e90: b0 10 20 12 mov 0x12, %i0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
40008e94: 80 a6 a0 00 cmp %i2, 0
40008e98: 02 80 00 21 be 40008f1c <rtems_io_register_driver+0xb0>
40008e9c: 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 )
40008ea0: 02 80 00 1f be 40008f1c <rtems_io_register_driver+0xb0>
40008ea4: 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;
40008ea8: c4 06 40 00 ld [ %i1 ], %g2
40008eac: 80 a0 a0 00 cmp %g2, 0
40008eb0: 22 80 00 18 be,a 40008f10 <rtems_io_register_driver+0xa4>
40008eb4: 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 )
40008eb8: 80 a1 00 1d cmp %g4, %i5
40008ebc: 08 80 00 13 bleu 40008f08 <rtems_io_register_driver+0x9c>
40008ec0: 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;
40008ec4: 05 10 00 6c sethi %hi(0x4001b000), %g2
40008ec8: c8 00 a2 d0 ld [ %g2 + 0x2d0 ], %g4 ! 4001b2d0 <_Thread_Dispatch_disable_level>
++level;
40008ecc: 88 01 20 01 inc %g4
_Thread_Dispatch_disable_level = level;
40008ed0: c8 20 a2 d0 st %g4, [ %g2 + 0x2d0 ]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
40008ed4: 80 a7 60 00 cmp %i5, 0
40008ed8: 02 80 00 13 be 40008f24 <rtems_io_register_driver+0xb8>
40008edc: 39 10 00 6f sethi %hi(0x4001bc00), %i4
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
40008ee0: c8 07 20 2c ld [ %i4 + 0x2c ], %g4 ! 4001bc2c <_IO_Driver_address_table>
40008ee4: 85 2f 60 03 sll %i5, 3, %g2
40008ee8: b7 2f 60 05 sll %i5, 5, %i3
40008eec: 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;
40008ef0: f2 01 00 01 ld [ %g4 + %g1 ], %i1
40008ef4: 80 a6 60 00 cmp %i1, 0
40008ef8: 02 80 00 3a be 40008fe0 <rtems_io_register_driver+0x174>
40008efc: 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();
40008f00: 40 00 08 68 call 4000b0a0 <_Thread_Enable_dispatch>
40008f04: b0 10 20 0c mov 0xc, %i0
return RTEMS_RESOURCE_IN_USE;
40008f08: 81 c7 e0 08 ret
40008f0c: 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;
40008f10: 80 a0 a0 00 cmp %g2, 0
40008f14: 12 bf ff ea bne 40008ebc <rtems_io_register_driver+0x50>
40008f18: 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;
40008f1c: 81 c7 e0 08 ret
40008f20: 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;
40008f24: c8 00 60 28 ld [ %g1 + 0x28 ], %g4
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
40008f28: 80 a1 20 00 cmp %g4, 0
40008f2c: 02 80 00 33 be 40008ff8 <rtems_io_register_driver+0x18c> <== NEVER TAKEN
40008f30: c2 07 20 2c ld [ %i4 + 0x2c ], %g1
40008f34: 30 80 00 04 b,a 40008f44 <rtems_io_register_driver+0xd8>
40008f38: 80 a7 40 04 cmp %i5, %g4
40008f3c: 02 80 00 24 be 40008fcc <rtems_io_register_driver+0x160>
40008f40: 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;
40008f44: c4 00 40 00 ld [ %g1 ], %g2
40008f48: 80 a0 a0 00 cmp %g2, 0
40008f4c: 32 bf ff fb bne,a 40008f38 <rtems_io_register_driver+0xcc>
40008f50: ba 07 60 01 inc %i5
40008f54: c4 00 60 04 ld [ %g1 + 4 ], %g2
40008f58: 80 a0 a0 00 cmp %g2, 0
40008f5c: 32 bf ff f7 bne,a 40008f38 <rtems_io_register_driver+0xcc>
40008f60: ba 07 60 01 inc %i5
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
40008f64: fa 26 80 00 st %i5, [ %i2 ]
40008f68: 85 2f 60 03 sll %i5, 3, %g2
if ( m != n )
40008f6c: 80 a1 00 1d cmp %g4, %i5
40008f70: 02 80 00 18 be 40008fd0 <rtems_io_register_driver+0x164> <== NEVER TAKEN
40008f74: b7 2f 60 05 sll %i5, 5, %i3
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
40008f78: c8 00 c0 00 ld [ %g3 ], %g4
40008f7c: c2 07 20 2c ld [ %i4 + 0x2c ], %g1
40008f80: 84 26 c0 02 sub %i3, %g2, %g2
40008f84: c8 20 40 02 st %g4, [ %g1 + %g2 ]
40008f88: c8 00 e0 04 ld [ %g3 + 4 ], %g4
40008f8c: 82 00 40 02 add %g1, %g2, %g1
40008f90: c8 20 60 04 st %g4, [ %g1 + 4 ]
40008f94: c4 00 e0 08 ld [ %g3 + 8 ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
40008f98: b2 10 20 00 clr %i1
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
40008f9c: c4 20 60 08 st %g2, [ %g1 + 8 ]
40008fa0: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
40008fa4: b4 10 20 00 clr %i2
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
40008fa8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
40008fac: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
40008fb0: b0 10 00 1d mov %i5, %i0
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
40008fb4: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
40008fb8: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2
_Thread_Enable_dispatch();
40008fbc: 40 00 08 39 call 4000b0a0 <_Thread_Enable_dispatch>
40008fc0: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return rtems_io_initialize( major, 0, NULL );
40008fc4: 40 00 21 e9 call 40011768 <rtems_io_initialize>
40008fc8: 81 e8 00 00 restore
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
40008fcc: 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();
40008fd0: 40 00 08 34 call 4000b0a0 <_Thread_Enable_dispatch>
40008fd4: b0 10 20 05 mov 5, %i0
return sc;
40008fd8: 81 c7 e0 08 ret
40008fdc: 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;
40008fe0: c2 00 60 04 ld [ %g1 + 4 ], %g1
40008fe4: 80 a0 60 00 cmp %g1, 0
40008fe8: 12 bf ff c6 bne 40008f00 <rtems_io_register_driver+0x94>
40008fec: 01 00 00 00 nop
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
40008ff0: 10 bf ff e2 b 40008f78 <rtems_io_register_driver+0x10c>
40008ff4: fa 26 80 00 st %i5, [ %i2 ]
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
40008ff8: 10 bf ff f6 b 40008fd0 <rtems_io_register_driver+0x164> <== NOT EXECUTED
40008ffc: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
4000a160 <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)
{
4000a160: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
4000a164: 80 a6 20 00 cmp %i0, 0
4000a168: 02 80 00 20 be 4000a1e8 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
4000a16c: 37 10 00 86 sethi %hi(0x40021800), %i3
4000a170: b6 16 e2 58 or %i3, 0x258, %i3 ! 40021a58 <_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)
4000a174: 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 ];
4000a178: c2 06 c0 00 ld [ %i3 ], %g1
4000a17c: f8 00 60 04 ld [ %g1 + 4 ], %i4
if ( !information )
4000a180: 80 a7 20 00 cmp %i4, 0
4000a184: 22 80 00 16 be,a 4000a1dc <rtems_iterate_over_all_threads+0x7c>
4000a188: b6 06 e0 04 add %i3, 4, %i3
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
4000a18c: c2 17 20 10 lduh [ %i4 + 0x10 ], %g1
4000a190: 86 90 60 00 orcc %g1, 0, %g3
4000a194: 22 80 00 12 be,a 4000a1dc <rtems_iterate_over_all_threads+0x7c>
4000a198: b6 06 e0 04 add %i3, 4, %i3
4000a19c: ba 10 20 01 mov 1, %i5
the_thread = (Thread_Control *)information->local_table[ i ];
4000a1a0: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
4000a1a4: 83 2f 60 02 sll %i5, 2, %g1
4000a1a8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_thread )
4000a1ac: 90 90 60 00 orcc %g1, 0, %o0
4000a1b0: 02 80 00 05 be 4000a1c4 <rtems_iterate_over_all_threads+0x64><== NEVER TAKEN
4000a1b4: ba 07 60 01 inc %i5
continue;
(*routine)(the_thread);
4000a1b8: 9f c6 00 00 call %i0
4000a1bc: 01 00 00 00 nop
4000a1c0: 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++ ) {
4000a1c4: 83 28 e0 10 sll %g3, 0x10, %g1
4000a1c8: 83 30 60 10 srl %g1, 0x10, %g1
4000a1cc: 80 a0 40 1d cmp %g1, %i5
4000a1d0: 3a bf ff f5 bcc,a 4000a1a4 <rtems_iterate_over_all_threads+0x44>
4000a1d4: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
4000a1d8: 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++ ) {
4000a1dc: 80 a6 c0 1a cmp %i3, %i2
4000a1e0: 32 bf ff e7 bne,a 4000a17c <rtems_iterate_over_all_threads+0x1c>
4000a1e4: c2 06 c0 00 ld [ %i3 ], %g1
4000a1e8: 81 c7 e0 08 ret
4000a1ec: 81 e8 00 00 restore
40003178 <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 )
{
40003178: 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)
4000317c: 03 10 00 78 sethi %hi(0x4001e000), %g1
40003180: fa 00 63 a4 ld [ %g1 + 0x3a4 ], %i5 ! 4001e3a4 <rtems_libio_number_iops>
40003184: 80 a7 60 00 cmp %i5, 0
40003188: 02 80 00 1b be 400031f4 <rtems_libio_init+0x7c> <== NEVER TAKEN
4000318c: 92 10 20 01 mov 1, %o1
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
40003190: 90 10 00 1d mov %i5, %o0
40003194: 7f ff fe f6 call 40002d6c <calloc>
40003198: 92 10 20 38 mov 0x38, %o1
4000319c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
400031a0: 80 a2 20 00 cmp %o0, 0
400031a4: 02 80 00 28 be 40003244 <rtems_libio_init+0xcc>
400031a8: d0 20 61 30 st %o0, [ %g1 + 0x130 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
400031ac: 03 10 00 7b sethi %hi(0x4001ec00), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
400031b0: 80 a7 60 01 cmp %i5, 1
400031b4: 08 80 00 0e bleu 400031ec <rtems_libio_init+0x74>
400031b8: d0 20 61 34 st %o0, [ %g1 + 0x134 ]
400031bc: 82 10 00 08 mov %o0, %g1
400031c0: 84 10 20 01 mov 1, %g2
iop->data1 = iop + 1;
400031c4: 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++)
400031c8: 84 00 a0 01 inc %g2
400031cc: 80 a0 80 1d cmp %g2, %i5
400031d0: 12 bf ff fd bne 400031c4 <rtems_libio_init+0x4c>
400031d4: 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 )
400031d8: 84 00 bf ff add %g2, -1, %g2
400031dc: 83 28 a0 03 sll %g2, 3, %g1
400031e0: 85 28 a0 06 sll %g2, 6, %g2
400031e4: 84 20 80 01 sub %g2, %g1, %g2
400031e8: 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;
400031ec: c0 22 20 30 clr [ %o0 + 0x30 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
400031f0: 92 10 20 01 mov 1, %o1
400031f4: 11 13 10 92 sethi %hi(0x4c424800), %o0
400031f8: 94 10 20 54 mov 0x54, %o2
400031fc: 90 12 21 4f or %o0, 0x14f, %o0
40003200: 96 10 20 00 clr %o3
40003204: 19 10 00 7b sethi %hi(0x4001ec00), %o4
40003208: 40 00 0f b9 call 400070ec <rtems_semaphore_create>
4000320c: 98 13 21 38 or %o4, 0x138, %o4 ! 4001ed38 <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
40003210: 80 a2 20 00 cmp %o0, 0
40003214: 12 80 00 0a bne 4000323c <rtems_libio_init+0xc4> <== NEVER TAKEN
40003218: 03 10 00 78 sethi %hi(0x4001e000), %g1
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
4000321c: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 4001e3a8 <rtems_fs_init_helper>
40003220: 80 a0 60 00 cmp %g1, 0
40003224: 02 80 00 04 be 40003234 <rtems_libio_init+0xbc>
40003228: 01 00 00 00 nop
(* rtems_fs_init_helper)();
4000322c: 9f c0 40 00 call %g1
40003230: 01 00 00 00 nop
40003234: 81 c7 e0 08 ret
40003238: 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 );
4000323c: 40 00 12 39 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40003240: 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);
40003244: 40 00 12 37 call 40007b20 <rtems_fatal_error_occurred>
40003248: 90 10 20 1a mov 0x1a, %o0 ! 1a <PROM_START+0x1a>
40004628 <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
40004628: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
4000462c: 40 00 06 73 call 40005ff8 <rtems_task_self>
40004630: 37 10 00 54 sethi %hi(0x40015000), %i3
rtems_user_env_t *old_env = rtems_current_user_env;
40004634: fa 06 e2 5c ld [ %i3 + 0x25c ], %i5 ! 4001525c <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;
40004638: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
4000463c: 80 a0 40 08 cmp %g1, %o0
40004640: 12 80 00 07 bne 4000465c <rtems_libio_set_private_env+0x34>
40004644: 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;
40004648: 03 10 00 54 sethi %hi(0x40015000), %g1
4000464c: 82 10 62 60 or %g1, 0x260, %g1 ! 40015260 <rtems_global_user_env>
bool uses_shared_env = old_env->task_id != self_task_id;
if (uses_global_env || uses_shared_env) {
40004650: 80 a7 40 01 cmp %i5, %g1
40004654: 12 80 00 2a bne 400046fc <rtems_libio_set_private_env+0xd4><== ALWAYS TAKEN
40004658: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
4000465c: 90 10 20 01 mov 1, %o0
40004660: 92 10 20 2c mov 0x2c, %o1
40004664: 40 00 14 a6 call 400098fc <calloc>
40004668: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
4000466c: 80 a2 20 00 cmp %o0, 0
40004670: 02 80 00 23 be 400046fc <rtems_libio_set_private_env+0xd4>
40004674: b4 10 00 08 mov %o0, %i2
*new_env = *old_env;
40004678: 92 10 00 1d mov %i5, %o1
4000467c: 40 00 20 b0 call 4000c93c <memcpy>
40004680: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
40004684: 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);
40004688: 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;
4000468c: 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);
40004690: 40 00 03 10 call 400052d0 <rtems_filesystem_global_location_obtain>
40004694: 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 =
40004698: 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);
4000469c: 40 00 03 0d call 400052d0 <rtems_filesystem_global_location_obtain>
400046a0: 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;
400046a4: 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 =
400046a8: d0 26 80 00 st %o0, [ %i2 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
400046ac: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
400046b0: 03 10 00 51 sethi %hi(0x40014400), %g1
400046b4: 82 10 63 14 or %g1, 0x314, %g1 ! 40014714 <rtems_filesystem_null_handlers>
400046b8: 80 a0 80 01 cmp %g2, %g1
400046bc: 22 80 00 0e be,a 400046f4 <rtems_libio_set_private_env+0xcc>
400046c0: 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)
400046c4: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
400046c8: 80 a0 80 01 cmp %g2, %g1
400046cc: 02 80 00 0e be 40004704 <rtems_libio_set_private_env+0xdc><== NEVER TAKEN
400046d0: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
400046d4: 92 16 e2 5c or %i3, 0x25c, %o1
400046d8: 15 10 00 11 sethi %hi(0x40004400), %o2
400046dc: 40 00 06 69 call 40006080 <rtems_task_variable_add>
400046e0: 94 12 a1 b8 or %o2, 0x1b8, %o2 ! 400045b8 <free_user_env>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
400046e4: b0 92 20 00 orcc %o0, 0, %i0
400046e8: 02 80 00 09 be 4000470c <rtems_libio_set_private_env+0xe4>
400046ec: 01 00 00 00 nop
free_user_env_protected(old_env);
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
400046f0: b0 10 20 05 mov 5, %i0 ! 5 <PROM_START+0x5>
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
400046f4: 7f ff ff b1 call 400045b8 <free_user_env>
400046f8: 90 10 00 1a mov %i2, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
400046fc: 81 c7 e0 08 ret
40004700: 81 e8 00 00 restore
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
}
} else {
sc = RTEMS_UNSATISFIED;
40004704: 10 bf ff fc b 400046f4 <rtems_libio_set_private_env+0xcc> <== NOT EXECUTED
40004708: 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);
4000470c: 7f ff ff be call 40004604 <free_user_env_protected>
40004710: 90 10 00 1d mov %i5, %o0
rtems_current_user_env = new_env;
40004714: 03 10 00 54 sethi %hi(0x40015000), %g1
40004718: f4 20 62 5c st %i2, [ %g1 + 0x25c ] ! 4001525c <rtems_current_user_env>
4000471c: 81 c7 e0 08 ret
40004720: 81 e8 00 00 restore
40004724 <rtems_libio_share_private_env>:
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
40004724: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
40004728: 40 00 06 34 call 40005ff8 <rtems_task_self>
4000472c: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
40004730: 80 a2 00 18 cmp %o0, %i0
40004734: 12 80 00 04 bne 40004744 <rtems_libio_share_private_env+0x20>
40004738: 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;
4000473c: 81 c7 e0 08 ret
40004740: 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) {
40004744: 02 bf ff fe be 4000473c <rtems_libio_share_private_env+0x18>
40004748: 03 10 00 57 sethi %hi(0x40015c00), %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;
4000474c: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 40015cc0 <_Thread_Dispatch_disable_level>
++level;
40004750: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40004754: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
40004758: 3b 10 00 54 sethi %hi(0x40015000), %i5
4000475c: 90 10 00 18 mov %i0, %o0
40004760: 92 17 62 5c or %i5, 0x25c, %o1
40004764: 40 00 06 a7 call 40006200 <rtems_task_variable_get>
40004768: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
4000476c: 80 a2 20 00 cmp %o0, 0
40004770: 12 80 00 14 bne 400047c0 <rtems_libio_share_private_env+0x9c>
40004774: c2 07 bf fc ld [ %fp + -4 ], %g1
++env->reference_count;
40004778: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
4000477c: 84 00 a0 01 inc %g2
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
40004780: 40 00 0f 1c call 400083f0 <_Thread_Enable_dispatch>
40004784: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_task_variable_add(
40004788: 90 10 20 00 clr %o0
4000478c: 92 17 62 5c or %i5, 0x25c, %o1
40004790: 15 10 00 11 sethi %hi(0x40004400), %o2
40004794: 40 00 06 3b call 40006080 <rtems_task_variable_add>
40004798: 94 12 a1 b8 or %o2, 0x1b8, %o2 ! 400045b8 <free_user_env>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
4000479c: b0 92 20 00 orcc %o0, 0, %i0
400047a0: 12 80 00 0c bne 400047d0 <rtems_libio_share_private_env+0xac><== NEVER TAKEN
400047a4: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
400047a8: 7f ff ff 97 call 40004604 <free_user_env_protected>
400047ac: d0 07 62 5c ld [ %i5 + 0x25c ], %o0
rtems_current_user_env = env;
400047b0: c2 07 bf fc ld [ %fp + -4 ], %g1
400047b4: c2 27 62 5c st %g1, [ %i5 + 0x25c ]
400047b8: 81 c7 e0 08 ret
400047bc: 81 e8 00 00 restore
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
400047c0: 40 00 0f 0c call 400083f0 <_Thread_Enable_dispatch>
400047c4: b0 10 20 0d mov 0xd, %i0
}
}
}
return sc;
}
400047c8: 81 c7 e0 08 ret
400047cc: 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);
400047d0: 7f ff ff 8d call 40004604 <free_user_env_protected> <== NOT EXECUTED
400047d4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
400047d8: 81 c7 e0 08 ret <== NOT EXECUTED
400047dc: 81 e8 00 00 restore <== NOT EXECUTED
4000be80 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
4000be80: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000be84: 84 08 60 06 and %g1, 6, %g2
4000be88: 80 a0 a0 06 cmp %g2, 6
4000be8c: 02 80 00 05 be 4000bea0 <rtems_libio_to_fcntl_flags+0x20>
4000be90: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
4000be94: 80 88 60 02 btst 2, %g1
4000be98: 02 80 00 0e be 4000bed0 <rtems_libio_to_fcntl_flags+0x50> <== NEVER TAKEN
4000be9c: 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 ) {
4000bea0: 80 88 60 01 btst 1, %g1
4000bea4: 02 80 00 04 be 4000beb4 <rtems_libio_to_fcntl_flags+0x34>
4000bea8: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
4000beac: 05 00 00 10 sethi %hi(0x4000), %g2
4000beb0: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
4000beb4: 32 80 00 02 bne,a 4000bebc <rtems_libio_to_fcntl_flags+0x3c>
4000beb8: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
4000bebc: 80 88 64 00 btst 0x400, %g1
4000bec0: 32 80 00 02 bne,a 4000bec8 <rtems_libio_to_fcntl_flags+0x48>
4000bec4: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
4000bec8: 81 c3 e0 08 retl
4000becc: 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) {
4000bed0: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
4000bed4: 10 bf ff f3 b 4000bea0 <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
4000bed8: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
400047e0 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
400047e0: 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) {
400047e4: 3b 10 00 54 sethi %hi(0x40015000), %i5
400047e8: c2 07 62 5c ld [ %i5 + 0x25c ], %g1 ! 4001525c <rtems_current_user_env>
400047ec: 39 10 00 54 sethi %hi(0x40015000), %i4
400047f0: b8 17 22 60 or %i4, 0x260, %i4 ! 40015260 <rtems_global_user_env>
400047f4: 80 a0 40 1c cmp %g1, %i4
400047f8: 02 80 00 08 be 40004818 <rtems_libio_use_global_env+0x38>
400047fc: 92 17 62 5c or %i5, 0x25c, %o1
sc = rtems_task_variable_delete(
40004800: 40 00 06 52 call 40006148 <rtems_task_variable_delete>
40004804: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
40004808: 80 a2 20 00 cmp %o0, 0
4000480c: 12 80 00 05 bne 40004820 <rtems_libio_use_global_env+0x40><== NEVER TAKEN
40004810: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
40004814: f8 27 62 5c st %i4, [ %i5 + 0x25c ]
40004818: 81 c7 e0 08 ret
4000481c: 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);
40004820: 40 00 07 0c call 40006450 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004824: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
400078c0 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
400078c0: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
400078c4: 03 10 00 93 sethi %hi(0x40024c00), %g1
400078c8: d0 00 61 b4 ld [ %g1 + 0x1b4 ], %o0 ! 40024db4 <RTEMS_Malloc_Heap>
400078cc: 92 10 00 18 mov %i0, %o1
400078d0: 40 00 1c ef call 4000ec8c <_Protected_heap_Get_block_size>
400078d4: 94 07 bf fc add %fp, -4, %o2
400078d8: 80 8a 20 ff btst 0xff, %o0
400078dc: 02 80 00 08 be 400078fc <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
400078e0: 03 10 00 98 sethi %hi(0x40026000), %g1
MSBUMP(lifetime_freed, size);
400078e4: c8 07 bf fc ld [ %fp + -4 ], %g4
400078e8: 82 10 60 80 or %g1, 0x80, %g1
400078ec: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
400078f0: 86 80 c0 04 addcc %g3, %g4, %g3
400078f4: 84 40 a0 00 addx %g2, 0, %g2
400078f8: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
400078fc: 81 c7 e0 08 ret
40007900: 81 e8 00 00 restore
40007904 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
40007904: 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 )
40007908: 80 a6 20 00 cmp %i0, 0
4000790c: 02 80 00 14 be 4000795c <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
40007910: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
40007914: 03 10 00 93 sethi %hi(0x40024c00), %g1
40007918: d0 00 61 b4 ld [ %g1 + 0x1b4 ], %o0 ! 40024db4 <RTEMS_Malloc_Heap>
4000791c: 92 10 00 18 mov %i0, %o1
40007920: 40 00 1c db call 4000ec8c <_Protected_heap_Get_block_size>
40007924: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
40007928: 03 10 00 98 sethi %hi(0x40026000), %g1
4000792c: f8 07 bf fc ld [ %fp + -4 ], %i4
40007930: 82 10 60 80 or %g1, 0x80, %g1
40007934: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
40007938: fa 00 60 2c ld [ %g1 + 0x2c ], %i5
if (current_depth > s->max_depth)
4000793c: 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);
40007940: 86 80 c0 1c addcc %g3, %i4, %g3
40007944: 84 40 a0 00 addx %g2, 0, %g2
40007948: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
4000794c: 84 20 c0 1d sub %g3, %i5, %g2
if (current_depth > s->max_depth)
40007950: 80 a0 80 04 cmp %g2, %g4
40007954: 38 80 00 02 bgu,a 4000795c <rtems_malloc_statistics_at_malloc+0x58>
40007958: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
4000795c: 81 c7 e0 08 ret
40007960: 81 e8 00 00 restore
400103c4 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
400103c4: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
400103c8: ba 96 20 00 orcc %i0, 0, %i5
400103cc: 02 80 00 21 be 40010450 <rtems_memalign+0x8c>
400103d0: 03 10 00 6d sethi %hi(0x4001b400), %g1
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
400103d4: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1 ! 4001b7d8 <_System_state_Current>
400103d8: 80 a0 60 03 cmp %g1, 3
400103dc: 02 80 00 18 be 4001043c <rtems_memalign+0x78>
400103e0: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
400103e4: 7f ff d0 20 call 40004464 <malloc_deferred_frees_process>
400103e8: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
400103ec: 03 10 00 69 sethi %hi(0x4001a400), %g1
400103f0: d0 00 62 f8 ld [ %g1 + 0x2f8 ], %o0 ! 4001a6f8 <RTEMS_Malloc_Heap>
400103f4: 92 10 00 1a mov %i2, %o1
400103f8: 94 10 00 19 mov %i1, %o2
400103fc: 7f ff e8 53 call 4000a548 <_Protected_heap_Allocate_aligned_with_boundary>
40010400: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
40010404: 80 a2 20 00 cmp %o0, 0
40010408: 02 80 00 14 be 40010458 <rtems_memalign+0x94>
4001040c: b8 10 00 08 mov %o0, %i4
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
40010410: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40010414: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 4001ae00 <rtems_malloc_statistics_helpers>
40010418: 80 a0 60 00 cmp %g1, 0
4001041c: 22 80 00 06 be,a 40010434 <rtems_memalign+0x70>
40010420: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
40010424: c2 00 60 04 ld [ %g1 + 4 ], %g1
40010428: 9f c0 40 00 call %g1
4001042c: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
40010430: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
40010434: 81 c7 e0 08 ret
40010438: 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() )
4001043c: 7f ff cf fd call 40004430 <malloc_is_system_state_OK>
40010440: 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()) &&
40010444: 80 8a 20 ff btst 0xff, %o0
40010448: 12 bf ff e7 bne 400103e4 <rtems_memalign+0x20> <== ALWAYS TAKEN
4001044c: 01 00 00 00 nop
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
40010450: 81 c7 e0 08 ret
40010454: 91 e8 20 16 restore %g0, 0x16, %o0
40010458: 81 c7 e0 08 ret
4001045c: 81 e8 00 00 restore
4000938c <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4000938c: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
40009390: 40 00 6d ad call 40024a44 <strdup>
40009394: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
40009398: b6 92 20 00 orcc %o0, 0, %i3
4000939c: 02 80 00 69 be 40009540 <rtems_mkdir+0x1b4>
400093a0: 01 00 00 00 nop
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
400093a4: c2 0e c0 00 ldub [ %i3 ], %g1
400093a8: 83 28 60 18 sll %g1, 0x18, %g1
400093ac: 85 38 60 18 sra %g1, 0x18, %g2
400093b0: 80 a0 a0 2f cmp %g2, 0x2f
400093b4: 02 80 00 57 be 40009510 <rtems_mkdir+0x184>
400093b8: ba 10 00 1b mov %i3, %i5
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
400093bc: 83 38 60 18 sra %g1, 0x18, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
400093c0: b4 10 20 00 clr %i2
400093c4: 84 10 20 01 mov 1, %g2
retval = 0;
break;
}
}
if (!last)
*p = '/';
400093c8: 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)) {
400093cc: 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')
400093d0: 80 a0 60 00 cmp %g1, 0
400093d4: 02 80 00 0b be 40009400 <rtems_mkdir+0x74> <== NEVER TAKEN
400093d8: 21 00 00 10 sethi %hi(0x4000), %l0
last = 1;
else if (p[0] != '/')
400093dc: 80 a0 60 2f cmp %g1, 0x2f
400093e0: 22 80 00 2f be,a 4000949c <rtems_mkdir+0x110>
400093e4: c2 4f 60 01 ldsb [ %i5 + 1 ], %g1
400093e8: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
400093ec: 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')
400093f0: 83 38 60 18 sra %g1, 0x18, %g1
400093f4: 80 a0 60 00 cmp %g1, 0
400093f8: 12 bf ff f9 bne 400093dc <rtems_mkdir+0x50>
400093fc: ba 07 60 01 inc %i5
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
40009400: c0 2f 40 00 clrb [ %i5 ]
40009404: b8 10 20 01 mov 1, %i4
if (!last && p[1] == '\0')
last = 1;
if (first) {
40009408: 80 a0 a0 00 cmp %g2, 0
4000940c: 12 80 00 1d bne 40009480 <rtems_mkdir+0xf4>
40009410: 01 00 00 00 nop
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
40009414: 80 a7 20 00 cmp %i4, 0
40009418: 12 80 00 0a bne 40009440 <rtems_mkdir+0xb4>
4000941c: 90 10 00 1b mov %i3, %o0
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40009420: 7f ff fc a4 call 400086b0 <mkdir>
40009424: 92 10 21 ff mov 0x1ff, %o1
40009428: 80 a2 20 00 cmp %o0, 0
4000942c: 06 80 00 20 bl 400094ac <rtems_mkdir+0x120>
40009430: 01 00 00 00 nop
retval = 0;
break;
}
}
if (!last)
*p = '/';
40009434: f0 2f 40 00 stb %i0, [ %i5 ]
40009438: 10 bf ff ec b 400093e8 <rtems_mkdir+0x5c>
4000943c: 84 10 20 00 clr %g2
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
40009440: 40 00 0a a0 call 4000bec0 <umask>
40009444: 90 10 00 1a mov %i2, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40009448: 90 10 00 1b mov %i3, %o0
4000944c: 7f ff fc 99 call 400086b0 <mkdir>
40009450: 92 10 00 19 mov %i1, %o1
40009454: 80 a2 20 00 cmp %o0, 0
40009458: 06 80 00 15 bl 400094ac <rtems_mkdir+0x120>
4000945c: 01 00 00 00 nop
40009460: 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);
40009464: 7f ff fa b9 call 40007f48 <free>
40009468: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
4000946c: 80 a7 60 00 cmp %i5, 0
40009470: 02 80 00 34 be 40009540 <rtems_mkdir+0x1b4> <== NEVER TAKEN
40009474: b0 10 20 00 clr %i0
}
40009478: 81 c7 e0 08 ret
4000947c: 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);
40009480: 40 00 0a 90 call 4000bec0 <umask>
40009484: 90 10 20 00 clr %o0
40009488: b4 10 00 08 mov %o0, %i2
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
4000948c: 40 00 0a 8d call 4000bec0 <umask>
40009490: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
40009494: 10 bf ff e1 b 40009418 <rtems_mkdir+0x8c>
40009498: 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';
4000949c: c0 2f 40 00 clrb [ %i5 ]
400094a0: 80 a0 00 01 cmp %g0, %g1
400094a4: 10 bf ff d9 b 40009408 <rtems_mkdir+0x7c>
400094a8: 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) {
400094ac: 40 00 65 23 call 40022938 <__errno>
400094b0: 01 00 00 00 nop
400094b4: c2 02 00 00 ld [ %o0 ], %g1
400094b8: 80 a0 60 11 cmp %g1, 0x11
400094bc: 02 80 00 08 be 400094dc <rtems_mkdir+0x150>
400094c0: 90 10 00 1b mov %i3, %o0
400094c4: 40 00 65 1d call 40022938 <__errno>
400094c8: 01 00 00 00 nop
400094cc: c2 02 00 00 ld [ %o0 ], %g1
400094d0: 80 a0 60 15 cmp %g1, 0x15
400094d4: 12 80 00 28 bne 40009574 <rtems_mkdir+0x1e8> <== ALWAYS TAKEN
400094d8: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
400094dc: 40 00 00 2a call 40009584 <stat>
400094e0: 92 07 bf b8 add %fp, -72, %o1
400094e4: 80 a2 20 00 cmp %o0, 0
400094e8: 06 80 00 23 bl 40009574 <rtems_mkdir+0x1e8> <== NEVER TAKEN
400094ec: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
400094f0: 82 08 40 11 and %g1, %l1, %g1
400094f4: 80 a0 40 10 cmp %g1, %l0
400094f8: 12 80 00 0a bne 40009520 <rtems_mkdir+0x194>
400094fc: 80 a7 20 00 cmp %i4, 0
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
40009500: 22 bf ff ce be,a 40009438 <rtems_mkdir+0xac>
40009504: f0 2f 40 00 stb %i0, [ %i5 ]
retval = 2;
40009508: 10 bf ff d7 b 40009464 <rtems_mkdir+0xd8>
4000950c: ba 10 20 02 mov 2, %i5
40009510: c2 0e e0 01 ldub [ %i3 + 1 ], %g1
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
40009514: ba 06 e0 01 add %i3, 1, %i5
40009518: 10 bf ff a9 b 400093bc <rtems_mkdir+0x30>
4000951c: 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)
40009520: 02 80 00 0a be 40009548 <rtems_mkdir+0x1bc>
40009524: 01 00 00 00 nop
errno = EEXIST;
40009528: 40 00 65 04 call 40022938 <__errno>
4000952c: 01 00 00 00 nop
40009530: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
40009534: 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);
40009538: 7f ff fa 84 call 40007f48 <free>
4000953c: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
40009540: 81 c7 e0 08 ret
40009544: 91 e8 3f ff restore %g0, -1, %o0
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
40009548: 40 00 64 fc call 40022938 <__errno>
4000954c: 01 00 00 00 nop
40009550: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
40009554: c2 22 00 00 st %g1, [ %o0 ]
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
40009558: 40 00 0a 5a call 4000bec0 <umask>
4000955c: 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);
40009560: 90 10 00 1b mov %i3, %o0
40009564: 7f ff fa 79 call 40007f48 <free>
40009568: b0 10 3f ff mov -1, %i0
4000956c: 81 c7 e0 08 ret
40009570: 81 e8 00 00 restore
}
}
if (!last)
*p = '/';
}
if (!first && !last)
40009574: 80 a7 20 00 cmp %i4, 0
40009578: 02 bf ff f8 be 40009558 <rtems_mkdir+0x1cc> <== NEVER TAKEN
4000957c: 90 10 00 1b mov %i3, %o0
40009580: 30 bf ff f9 b,a 40009564 <rtems_mkdir+0x1d8>
40008d68 <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
)
{
40008d68: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
40008d6c: 80 a6 a0 00 cmp %i2, 0
40008d70: 02 80 00 21 be 40008df4 <rtems_object_get_class_information+0x8c>
40008d74: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
40008d78: 93 2e 60 10 sll %i1, 0x10, %o1
40008d7c: 90 10 00 18 mov %i0, %o0
40008d80: 40 00 07 cc call 4000acb0 <_Objects_Get_information>
40008d84: 93 32 60 10 srl %o1, 0x10, %o1
if ( !obj_info )
40008d88: 80 a2 20 00 cmp %o0, 0
40008d8c: 02 80 00 1a be 40008df4 <rtems_object_get_class_information+0x8c>
40008d90: 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;
40008d94: 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;
40008d98: c6 02 20 08 ld [ %o0 + 8 ], %g3
info->maximum_id = obj_info->maximum_id;
40008d9c: c4 02 20 0c ld [ %o0 + 0xc ], %g2
info->auto_extend = obj_info->auto_extend;
40008da0: 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;
40008da4: c6 26 80 00 st %g3, [ %i2 ]
info->maximum_id = obj_info->maximum_id;
40008da8: c4 26 a0 04 st %g2, [ %i2 + 4 ]
info->auto_extend = obj_info->auto_extend;
40008dac: c2 2e a0 0c stb %g1, [ %i2 + 0xc ]
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40008db0: 80 a1 20 00 cmp %g4, 0
40008db4: 02 80 00 12 be 40008dfc <rtems_object_get_class_information+0x94><== NEVER TAKEN
40008db8: c8 26 a0 08 st %g4, [ %i2 + 8 ]
40008dbc: fa 02 20 1c ld [ %o0 + 0x1c ], %i5
40008dc0: 86 10 20 01 mov 1, %g3
40008dc4: 82 10 20 01 mov 1, %g1
40008dc8: 84 10 20 00 clr %g2
if ( !obj_info->local_table[i] )
40008dcc: 87 28 e0 02 sll %g3, 2, %g3
40008dd0: 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++ )
40008dd4: 82 00 60 01 inc %g1
if ( !obj_info->local_table[i] )
unallocated++;
40008dd8: 80 a0 00 03 cmp %g0, %g3
40008ddc: 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++ )
40008de0: 80 a1 00 01 cmp %g4, %g1
40008de4: 1a bf ff fa bcc 40008dcc <rtems_object_get_class_information+0x64>
40008de8: 86 10 00 01 mov %g1, %g3
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
40008dec: c4 26 a0 10 st %g2, [ %i2 + 0x10 ]
return RTEMS_SUCCESSFUL;
40008df0: 82 10 20 00 clr %g1
}
40008df4: 81 c7 e0 08 ret
40008df8: 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++ )
40008dfc: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
40008e00: 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;
40008e04: 10 bf ff fc b 40008df4 <rtems_object_get_class_information+0x8c><== NOT EXECUTED
40008e08: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] <== NOT EXECUTED
40002fd4 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
40002fd4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
40002fd8: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40002fdc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40002fe0: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
40002fe4: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
40002fe8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40002fec: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40002ff0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40002ff4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40002ff8: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40002ffc: 7f ff ff 77 call 40002dd8 <rtems_verror> <== NOT EXECUTED
40003000: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
40003004: 90 10 20 00 clr %o0 <== NOT EXECUTED
40003008: 13 10 00 72 sethi %hi(0x4001c800), %o1 <== NOT EXECUTED
4000300c: 7f ff ff d0 call 40002f4c <rtems_error> <== NOT EXECUTED
40003010: 92 12 62 10 or %o1, 0x210, %o1 ! 4001ca10 <IMFS_node_control_default+0xa0><== NOT EXECUTED
_exit(errno);
40003014: 40 00 31 cb call 4000f740 <__errno> <== NOT EXECUTED
40003018: 01 00 00 00 nop <== NOT EXECUTED
4000301c: 40 00 02 50 call 4000395c <_exit> <== NOT EXECUTED
40003020: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40008804 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
40008804: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
40008808: 80 a6 20 00 cmp %i0, 0
4000880c: 12 80 00 04 bne 4000881c <rtems_partition_create+0x18>
40008810: 82 10 20 03 mov 3, %g1
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
40008814: 81 c7 e0 08 ret
40008818: 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 )
4000881c: 80 a6 60 00 cmp %i1, 0
40008820: 02 bf ff fd be 40008814 <rtems_partition_create+0x10>
40008824: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
40008828: 80 a7 60 00 cmp %i5, 0
4000882c: 02 bf ff fa be 40008814 <rtems_partition_create+0x10> <== NEVER TAKEN
40008830: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
40008834: 02 bf ff f8 be 40008814 <rtems_partition_create+0x10>
40008838: 82 10 20 08 mov 8, %g1
4000883c: 80 a6 a0 00 cmp %i2, 0
40008840: 02 bf ff f5 be 40008814 <rtems_partition_create+0x10>
40008844: 80 a6 80 1b cmp %i2, %i3
40008848: 0a bf ff f3 bcs 40008814 <rtems_partition_create+0x10>
4000884c: 80 8e e0 07 btst 7, %i3
40008850: 12 bf ff f1 bne 40008814 <rtems_partition_create+0x10>
40008854: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
40008858: 12 bf ff ef bne 40008814 <rtems_partition_create+0x10>
4000885c: 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;
40008860: 03 10 00 8e sethi %hi(0x40023800), %g1
40008864: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 400238c0 <_Thread_Dispatch_disable_level>
++level;
40008868: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4000886c: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
* 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 );
40008870: 23 10 00 8d sethi %hi(0x40023400), %l1
40008874: 40 00 07 6f call 4000a630 <_Objects_Allocate>
40008878: 90 14 62 bc or %l1, 0x2bc, %o0 ! 400236bc <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
4000887c: a0 92 20 00 orcc %o0, 0, %l0
40008880: 02 80 00 1a be 400088e8 <rtems_partition_create+0xe4>
40008884: 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;
40008888: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
4000888c: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
40008890: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
40008894: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
40008898: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
4000889c: 40 00 47 d1 call 4001a7e0 <.udiv>
400088a0: 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,
400088a4: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
400088a8: 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,
400088ac: 96 10 00 1b mov %i3, %o3
400088b0: b8 04 20 24 add %l0, 0x24, %i4
400088b4: 40 00 04 a5 call 40009b48 <_Chain_Initialize>
400088b8: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
400088bc: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400088c0: a2 14 62 bc or %l1, 0x2bc, %l1
400088c4: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
400088c8: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400088cc: 85 28 a0 02 sll %g2, 2, %g2
400088d0: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
400088d4: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
400088d8: 40 00 0c a2 call 4000bb60 <_Thread_Enable_dispatch>
400088dc: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
400088e0: 10 bf ff cd b 40008814 <rtems_partition_create+0x10>
400088e4: 82 10 20 00 clr %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
400088e8: 40 00 0c 9e call 4000bb60 <_Thread_Enable_dispatch>
400088ec: 01 00 00 00 nop
return RTEMS_TOO_MANY;
400088f0: 10 bf ff c9 b 40008814 <rtems_partition_create+0x10>
400088f4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5>
40014fdc <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
40014fdc: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
40014fe0: 11 10 00 f4 sethi %hi(0x4003d000), %o0
40014fe4: 92 10 00 18 mov %i0, %o1
40014fe8: 90 12 22 64 or %o0, 0x264, %o0
40014fec: 40 00 15 26 call 4001a484 <_Objects_Get>
40014ff0: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
40014ff4: c2 07 bf fc ld [ %fp + -4 ], %g1
40014ff8: 80 a0 60 00 cmp %g1, 0
40014ffc: 12 80 00 19 bne 40015060 <rtems_partition_return_buffer+0x84>
40015000: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
40015004: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
40015008: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001500c: 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 ) &&
40015010: 80 a6 40 01 cmp %i1, %g1
40015014: 18 80 00 15 bgu 40015068 <rtems_partition_return_buffer+0x8c><== NEVER TAKEN
40015018: 80 a6 40 08 cmp %i1, %o0
4001501c: 0a 80 00 13 bcs 40015068 <rtems_partition_return_buffer+0x8c>
40015020: 01 00 00 00 nop
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
40015024: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
40015028: 40 00 5a e1 call 4002bbac <.urem>
4001502c: 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 ) &&
40015030: 80 a2 20 00 cmp %o0, 0
40015034: 12 80 00 0d bne 40015068 <rtems_partition_return_buffer+0x8c>
40015038: 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 );
4001503c: 40 00 0d 11 call 40018480 <_Chain_Append>
40015040: 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;
40015044: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
40015048: 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;
4001504c: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
40015050: 40 00 18 f0 call 4001b410 <_Thread_Enable_dispatch>
40015054: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
40015058: 81 c7 e0 08 ret
4001505c: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40015060: 81 c7 e0 08 ret
40015064: 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();
40015068: 40 00 18 ea call 4001b410 <_Thread_Enable_dispatch>
4001506c: b0 10 20 09 mov 9, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40015070: 81 c7 e0 08 ret
40015074: 81 e8 00 00 restore
40037900 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
40037900: 9d e3 bf 98 save %sp, -104, %sp
40037904: 11 10 01 a3 sethi %hi(0x40068c00), %o0
40037908: 92 10 00 18 mov %i0, %o1
4003790c: 90 12 23 78 or %o0, 0x378, %o0
40037910: 7f ff 44 18 call 40008970 <_Objects_Get>
40037914: 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 ) {
40037918: c2 07 bf fc ld [ %fp + -4 ], %g1
4003791c: 80 a0 60 00 cmp %g1, 0
40037920: 12 80 00 0d bne 40037954 <rtems_rate_monotonic_period+0x54>
40037924: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
40037928: 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 );
4003792c: 39 10 01 a2 sethi %hi(0x40068800), %i4
40037930: b8 17 21 b0 or %i4, 0x1b0, %i4 ! 400689b0 <_Per_CPU_Information>
40037934: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40037938: 80 a0 80 01 cmp %g2, %g1
4003793c: 02 80 00 08 be 4003795c <rtems_rate_monotonic_period+0x5c>
40037940: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
40037944: 7f ff 47 c2 call 4000984c <_Thread_Enable_dispatch>
40037948: b0 10 20 17 mov 0x17, %i0
4003794c: 81 c7 e0 08 ret
40037950: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40037954: 81 c7 e0 08 ret
40037958: 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 ) {
4003795c: 12 80 00 0e bne 40037994 <rtems_rate_monotonic_period+0x94>
40037960: 01 00 00 00 nop
switch ( the_period->state ) {
40037964: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40037968: 80 a0 60 04 cmp %g1, 4
4003796c: 18 80 00 06 bgu 40037984 <rtems_rate_monotonic_period+0x84><== NEVER TAKEN
40037970: b0 10 20 00 clr %i0
40037974: 83 28 60 02 sll %g1, 2, %g1
40037978: 05 10 01 88 sethi %hi(0x40062000), %g2
4003797c: 84 10 a3 50 or %g2, 0x350, %g2 ! 40062350 <CSWTCH.24>
40037980: f0 00 80 01 ld [ %g2 + %g1 ], %i0
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
40037984: 7f ff 47 b2 call 4000984c <_Thread_Enable_dispatch>
40037988: 01 00 00 00 nop
4003798c: 81 c7 e0 08 ret
40037990: 81 e8 00 00 restore
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
40037994: 7f ff 29 38 call 40001e74 <sparc_disable_interrupts>
40037998: 01 00 00 00 nop
4003799c: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
400379a0: f6 07 60 38 ld [ %i5 + 0x38 ], %i3
400379a4: 80 a6 e0 00 cmp %i3, 0
400379a8: 02 80 00 1c be 40037a18 <rtems_rate_monotonic_period+0x118>
400379ac: 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 ) {
400379b0: 02 80 00 2e be 40037a68 <rtems_rate_monotonic_period+0x168>
400379b4: 80 a6 e0 04 cmp %i3, 4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
400379b8: 12 bf ff e5 bne 4003794c <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
400379bc: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
400379c0: 7f ff ff 5e call 40037738 <_Rate_monotonic_Update_statistics>
400379c4: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
400379c8: 7f ff 29 2f call 40001e84 <sparc_enable_interrupts>
400379cc: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
400379d0: 82 10 20 02 mov 2, %g1
400379d4: 92 07 60 10 add %i5, 0x10, %o1
400379d8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
400379dc: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
400379e0: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
400379e4: 11 10 01 a1 sethi %hi(0x40068400), %o0
400379e8: 7f ff 4a d5 call 4000a53c <_Watchdog_Insert>
400379ec: 90 12 21 38 or %o0, 0x138, %o0 ! 40068538 <_Watchdog_Ticks_chain>
400379f0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
400379f4: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
400379f8: 03 10 01 90 sethi %hi(0x40064000), %g1
400379fc: c2 00 62 14 ld [ %g1 + 0x214 ], %g1 ! 40064214 <_Scheduler+0x34>
40037a00: 9f c0 40 00 call %g1
40037a04: 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();
40037a08: 7f ff 47 91 call 4000984c <_Thread_Enable_dispatch>
40037a0c: 01 00 00 00 nop
40037a10: 81 c7 e0 08 ret
40037a14: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
40037a18: 7f ff 29 1b call 40001e84 <sparc_enable_interrupts>
40037a1c: 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 );
40037a20: 90 10 00 1d mov %i5, %o0
40037a24: 7f ff ff 94 call 40037874 <_Rate_monotonic_Initiate_statistics>
40037a28: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
40037a2c: 82 10 20 02 mov 2, %g1
40037a30: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40037a34: 03 10 00 de sethi %hi(0x40037800), %g1
40037a38: 82 10 62 dc or %g1, 0x2dc, %g1 ! 40037adc <_Rate_monotonic_Timeout>
the_watchdog->id = id;
40037a3c: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40037a40: 92 07 60 10 add %i5, 0x10, %o1
40037a44: 11 10 01 a1 sethi %hi(0x40068400), %o0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40037a48: c0 27 60 18 clr [ %i5 + 0x18 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40037a4c: 90 12 21 38 or %o0, 0x138, %o0
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40037a50: c0 27 60 34 clr [ %i5 + 0x34 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40037a54: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40037a58: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40037a5c: 7f ff 4a b8 call 4000a53c <_Watchdog_Insert>
40037a60: b0 10 20 00 clr %i0
40037a64: 30 bf ff c8 b,a 40037984 <rtems_rate_monotonic_period+0x84>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
40037a68: 7f ff ff 34 call 40037738 <_Rate_monotonic_Update_statistics>
40037a6c: 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;
40037a70: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
40037a74: 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;
40037a78: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
40037a7c: 7f ff 29 02 call 40001e84 <sparc_enable_interrupts>
40037a80: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
40037a84: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40037a88: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40037a8c: 90 10 00 01 mov %g1, %o0
40037a90: 13 00 00 10 sethi %hi(0x4000), %o1
40037a94: 7f ff 49 be call 4000a18c <_Thread_Set_state>
40037a98: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
40037a9c: 7f ff 28 f6 call 40001e74 <sparc_disable_interrupts>
40037aa0: 01 00 00 00 nop
local_state = the_period->state;
40037aa4: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
40037aa8: f6 27 60 38 st %i3, [ %i5 + 0x38 ]
_ISR_Enable( level );
40037aac: 7f ff 28 f6 call 40001e84 <sparc_enable_interrupts>
40037ab0: 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 )
40037ab4: 80 a6 a0 03 cmp %i2, 3
40037ab8: 22 80 00 06 be,a 40037ad0 <rtems_rate_monotonic_period+0x1d0>
40037abc: d0 07 20 10 ld [ %i4 + 0x10 ], %o0
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
40037ac0: 7f ff 47 63 call 4000984c <_Thread_Enable_dispatch>
40037ac4: b0 10 20 00 clr %i0
40037ac8: 81 c7 e0 08 ret
40037acc: 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 );
40037ad0: 7f ff 46 72 call 40009498 <_Thread_Clear_state>
40037ad4: 13 00 00 10 sethi %hi(0x4000), %o1
40037ad8: 30 bf ff fa b,a 40037ac0 <rtems_rate_monotonic_period+0x1c0>
40029380 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40029380: 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 )
40029384: 80 a6 60 00 cmp %i1, 0
40029388: 02 80 00 48 be 400294a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
4002938c: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
40029390: 13 10 01 7d sethi %hi(0x4005f400), %o1
40029394: 9f c6 40 00 call %i1
40029398: 92 12 62 30 or %o1, 0x230, %o1 ! 4005f630 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
4002939c: 90 10 00 18 mov %i0, %o0
400293a0: 13 10 01 7d sethi %hi(0x4005f400), %o1
400293a4: 9f c6 40 00 call %i1
400293a8: 92 12 62 50 or %o1, 0x250, %o1 ! 4005f650 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
400293ac: 90 10 00 18 mov %i0, %o0
400293b0: 13 10 01 7d sethi %hi(0x4005f400), %o1
400293b4: 9f c6 40 00 call %i1
400293b8: 92 12 62 78 or %o1, 0x278, %o1 ! 4005f678 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
400293bc: 90 10 00 18 mov %i0, %o0
400293c0: 13 10 01 7d sethi %hi(0x4005f400), %o1
400293c4: 9f c6 40 00 call %i1
400293c8: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 4005f6a0 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
400293cc: 90 10 00 18 mov %i0, %o0
400293d0: 13 10 01 7d sethi %hi(0x4005f400), %o1
400293d4: 9f c6 40 00 call %i1
400293d8: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 4005f6f0 <_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 ;
400293dc: 39 10 01 a3 sethi %hi(0x40068c00), %i4
400293e0: b8 17 23 78 or %i4, 0x378, %i4 ! 40068f78 <_Rate_monotonic_Information>
400293e4: fa 07 20 08 ld [ %i4 + 8 ], %i5
400293e8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
400293ec: 80 a7 40 01 cmp %i5, %g1
400293f0: 18 80 00 2e bgu 400294a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
400293f4: 35 10 01 7d sethi %hi(0x4005f400), %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,
400293f8: 27 10 01 7d sethi %hi(0x4005f400), %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,
400293fc: 25 10 01 7d sethi %hi(0x4005f400), %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
40029400: 37 10 01 83 sethi %hi(0x40060c00), %i3
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
40029404: b4 16 a3 40 or %i2, 0x340, %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,
40029408: a6 14 e3 58 or %l3, 0x358, %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,
4002940c: a4 14 a3 78 or %l2, 0x378, %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
40029410: 10 80 00 06 b 40029428 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
40029414: b6 16 e0 00 mov %i3, %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++ ) {
40029418: 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 ;
4002941c: 80 a0 40 1d cmp %g1, %i5
40029420: 0a 80 00 22 bcs 400294a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128>
40029424: 01 00 00 00 nop
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
40029428: 90 10 00 1d mov %i5, %o0
4002942c: 40 00 37 df call 400373a8 <rtems_rate_monotonic_get_statistics>
40029430: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
40029434: 80 a2 20 00 cmp %o0, 0
40029438: 32 bf ff f8 bne,a 40029418 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
4002943c: 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 );
40029440: 92 07 bf b0 add %fp, -80, %o1
40029444: 40 00 38 4b call 40037570 <rtems_rate_monotonic_get_status>
40029448: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
4002944c: d0 07 bf b0 ld [ %fp + -80 ], %o0
40029450: 94 07 bf a0 add %fp, -96, %o2
40029454: 7f ff 97 6e call 4000f20c <rtems_object_get_name>
40029458: 92 10 20 05 mov 5, %o1
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
4002945c: d8 1f bf c8 ldd [ %fp + -56 ], %o4
40029460: 92 10 00 1a mov %i2, %o1
40029464: 94 10 00 1d mov %i5, %o2
40029468: 90 10 00 18 mov %i0, %o0
4002946c: 9f c6 40 00 call %i1
40029470: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
40029474: 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 );
40029478: 94 07 bf a8 add %fp, -88, %o2
4002947c: 90 07 bf e0 add %fp, -32, %o0
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
40029480: 80 a0 60 00 cmp %g1, 0
40029484: 12 80 00 0b bne 400294b0 <rtems_rate_monotonic_report_statistics_with_plugin+0x130>
40029488: 92 10 00 1b mov %i3, %o1
(*print)( context, "\n" );
4002948c: 9f c6 40 00 call %i1
40029490: 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 ;
40029494: c2 07 20 0c ld [ %i4 + 0xc ], %g1
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
40029498: 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 ;
4002949c: 80 a0 40 1d cmp %g1, %i5
400294a0: 1a bf ff e3 bcc 4002942c <rtems_rate_monotonic_report_statistics_with_plugin+0xac><== ALWAYS TAKEN
400294a4: 90 10 00 1d mov %i5, %o0
400294a8: 81 c7 e0 08 ret
400294ac: 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 );
400294b0: 40 00 03 5e call 4002a228 <_Timespec_Divide_by_integer>
400294b4: 92 10 00 01 mov %g1, %o1
(*print)( context,
400294b8: d0 07 bf d4 ld [ %fp + -44 ], %o0
400294bc: 40 00 ae e2 call 40055044 <.div>
400294c0: 92 10 23 e8 mov 0x3e8, %o1
400294c4: aa 10 00 08 mov %o0, %l5
400294c8: d0 07 bf dc ld [ %fp + -36 ], %o0
400294cc: 40 00 ae de call 40055044 <.div>
400294d0: 92 10 23 e8 mov 0x3e8, %o1
400294d4: c2 07 bf a8 ld [ %fp + -88 ], %g1
400294d8: a2 10 00 08 mov %o0, %l1
400294dc: d0 07 bf ac ld [ %fp + -84 ], %o0
400294e0: e0 07 bf d0 ld [ %fp + -48 ], %l0
400294e4: e8 07 bf d8 ld [ %fp + -40 ], %l4
400294e8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400294ec: 40 00 ae d6 call 40055044 <.div>
400294f0: 92 10 23 e8 mov 0x3e8, %o1
400294f4: 96 10 00 15 mov %l5, %o3
400294f8: 98 10 00 14 mov %l4, %o4
400294fc: 9a 10 00 11 mov %l1, %o5
40029500: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40029504: 92 10 00 13 mov %l3, %o1
40029508: 94 10 00 10 mov %l0, %o2
4002950c: 9f c6 40 00 call %i1
40029510: 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);
40029514: d2 07 bf c8 ld [ %fp + -56 ], %o1
40029518: 94 07 bf a8 add %fp, -88, %o2
4002951c: 40 00 03 43 call 4002a228 <_Timespec_Divide_by_integer>
40029520: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
40029524: d0 07 bf ec ld [ %fp + -20 ], %o0
40029528: 40 00 ae c7 call 40055044 <.div>
4002952c: 92 10 23 e8 mov 0x3e8, %o1
40029530: a8 10 00 08 mov %o0, %l4
40029534: d0 07 bf f4 ld [ %fp + -12 ], %o0
40029538: 40 00 ae c3 call 40055044 <.div>
4002953c: 92 10 23 e8 mov 0x3e8, %o1
40029540: c2 07 bf a8 ld [ %fp + -88 ], %g1
40029544: a0 10 00 08 mov %o0, %l0
40029548: d0 07 bf ac ld [ %fp + -84 ], %o0
4002954c: ea 07 bf e8 ld [ %fp + -24 ], %l5
40029550: e2 07 bf f0 ld [ %fp + -16 ], %l1
40029554: 92 10 23 e8 mov 0x3e8, %o1
40029558: 40 00 ae bb call 40055044 <.div>
4002955c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40029560: 92 10 00 12 mov %l2, %o1
40029564: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40029568: 94 10 00 15 mov %l5, %o2
4002956c: 90 10 00 18 mov %i0, %o0
40029570: 96 10 00 14 mov %l4, %o3
40029574: 98 10 00 11 mov %l1, %o4
40029578: 9f c6 40 00 call %i1
4002957c: 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 ;
40029580: 10 bf ff a6 b 40029418 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
40029584: c2 07 20 0c ld [ %i4 + 0xc ], %g1
400295a0 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
400295a0: 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;
400295a4: 03 10 01 a1 sethi %hi(0x40068400), %g1
400295a8: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 400684a0 <_Thread_Dispatch_disable_level>
++level;
400295ac: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400295b0: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ]
/*
* 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 ;
400295b4: 39 10 01 a3 sethi %hi(0x40068c00), %i4
400295b8: b8 17 23 78 or %i4, 0x378, %i4 ! 40068f78 <_Rate_monotonic_Information>
400295bc: fa 07 20 08 ld [ %i4 + 8 ], %i5
400295c0: c2 07 20 0c ld [ %i4 + 0xc ], %g1
400295c4: 80 a7 40 01 cmp %i5, %g1
400295c8: 18 80 00 09 bgu 400295ec <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
400295cc: 01 00 00 00 nop
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
400295d0: 40 00 00 09 call 400295f4 <rtems_rate_monotonic_reset_statistics>
400295d4: 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 ;
400295d8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
400295dc: 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 ;
400295e0: 80 a0 40 1d cmp %g1, %i5
400295e4: 1a bf ff fb bcc 400295d0 <rtems_rate_monotonic_reset_all_statistics+0x30>
400295e8: 01 00 00 00 nop
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
400295ec: 7f ff 80 98 call 4000984c <_Thread_Enable_dispatch>
400295f0: 81 e8 00 00 restore
400082f4 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
400082f4: 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;
400082f8: 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;
400082fc: 90 10 00 19 mov %i1, %o0
40008300: 40 00 2f 87 call 4001411c <.urem>
40008304: 92 10 00 1d mov %i5, %o1
if (excess > 0) {
40008308: 80 a2 20 00 cmp %o0, 0
4000830c: 02 80 00 26 be 400083a4 <rtems_rbheap_allocate+0xb0> <== ALWAYS TAKEN
40008310: b6 10 00 19 mov %i1, %i3
value += alignment - excess;
40008314: ba 06 40 1d add %i1, %i5, %i5 <== NOT EXECUTED
40008318: b6 27 40 08 sub %i5, %o0, %i3 <== NOT EXECUTED
4000831c: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
40008320: 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) {
40008324: 80 88 60 ff btst 0xff, %g1
40008328: 02 80 00 1d be 4000839c <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
4000832c: 80 a6 60 00 cmp %i1, 0
40008330: 02 80 00 1b be 4000839c <rtems_rbheap_allocate+0xa8>
40008334: 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;
40008338: 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) {
4000833c: 80 a7 40 01 cmp %i5, %g1
40008340: 02 80 00 17 be 4000839c <rtems_rbheap_allocate+0xa8>
40008344: 01 00 00 00 nop
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
40008348: f8 07 60 1c ld [ %i5 + 0x1c ], %i4
4000834c: 80 a6 c0 1c cmp %i3, %i4
40008350: 38 80 00 10 bgu,a 40008390 <rtems_rbheap_allocate+0x9c>
40008354: 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) {
40008358: 80 a7 60 00 cmp %i5, 0
4000835c: 02 80 00 10 be 4000839c <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
40008360: 80 a7 00 1b cmp %i4, %i3
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
40008364: 18 80 00 12 bgu 400083ac <rtems_rbheap_allocate+0xb8>
40008368: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000836c: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40008370: 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;
40008374: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
40008378: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000837c: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
40008380: c0 27 60 04 clr [ %i5 + 4 ]
40008384: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
40008388: 81 c7 e0 08 ret
4000838c: 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) {
40008390: 80 a0 40 1d cmp %g1, %i5
40008394: 32 bf ff ee bne,a 4000834c <rtems_rbheap_allocate+0x58> <== NEVER TAKEN
40008398: 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;
4000839c: 81 c7 e0 08 ret
400083a0: 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) {
400083a4: 10 bf ff e0 b 40008324 <rtems_rbheap_allocate+0x30>
400083a8: 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);
400083ac: 7f ff ff 46 call 400080c4 <get_chunk>
400083b0: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
400083b4: b4 92 20 00 orcc %o0, 0, %i2
400083b8: 02 bf ff f9 be 4000839c <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
400083bc: 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;
400083c0: 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;
400083c4: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
400083c8: 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;
400083cc: b8 07 00 01 add %i4, %g1, %i4
400083d0: c0 26 a0 04 clr [ %i2 + 4 ]
400083d4: f8 26 a0 18 st %i4, [ %i2 + 0x18 ]
400083d8: 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);
400083dc: 90 06 20 18 add %i0, 0x18, %o0
400083e0: 40 00 06 fd call 40009fd4 <_RBTree_Insert_unprotected>
400083e4: 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;
400083e8: f0 06 a0 18 ld [ %i2 + 0x18 ], %i0
400083ec: 81 c7 e0 08 ret
400083f0: 81 e8 00 00 restore
40008538 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
40008538: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
4000853c: 7f ff ec de call 400038b4 <malloc> <== NOT EXECUTED
40008540: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
40008544: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008548: 02 80 00 07 be 40008564 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
4000854c: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40008550: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
40008554: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40008558: 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;
4000855c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
40008560: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
40008564: 81 c7 e0 08 ret <== NOT EXECUTED
40008568: 81 e8 00 00 restore <== NOT EXECUTED
400083f4 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
400083f4: 9d e3 bf 80 save %sp, -128, %sp
400083f8: b4 10 00 18 mov %i0, %i2
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
400083fc: 80 a6 60 00 cmp %i1, 0
40008400: 02 80 00 2a be 400084a8 <rtems_rbheap_free+0xb4>
40008404: 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;
40008408: 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 };
4000840c: c0 27 bf fc clr [ %fp + -4 ]
40008410: c0 27 bf e0 clr [ %fp + -32 ]
40008414: c0 27 bf e4 clr [ %fp + -28 ]
40008418: c0 27 bf e8 clr [ %fp + -24 ]
4000841c: c0 27 bf ec clr [ %fp + -20 ]
40008420: c0 27 bf f0 clr [ %fp + -16 ]
40008424: c0 27 bf f4 clr [ %fp + -12 ]
40008428: f2 27 bf f8 st %i1, [ %fp + -8 ]
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
4000842c: 80 a7 60 00 cmp %i5, 0
40008430: 02 80 00 3e be 40008528 <rtems_rbheap_free+0x134> <== NEVER TAKEN
40008434: b8 06 a0 18 add %i2, 0x18, %i4
40008438: b6 10 20 00 clr %i3
compare_result = the_rbtree->compare_function(the_node, iter_node);
4000843c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40008440: 92 10 00 1d mov %i5, %o1
40008444: 9f c0 40 00 call %g1
40008448: 90 07 bf e8 add %fp, -24, %o0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
4000844c: 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 ) ) {
40008450: 80 a2 20 00 cmp %o0, 0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
40008454: 82 20 40 08 sub %g1, %o0, %g1
40008458: 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];
4000845c: 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 ) ) {
40008460: 12 80 00 06 bne 40008478 <rtems_rbheap_free+0x84>
40008464: 82 07 40 01 add %i5, %g1, %g1
found = iter_node;
if ( the_rbtree->is_unique )
40008468: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
4000846c: 80 a0 a0 00 cmp %g2, 0
40008470: 12 80 00 10 bne 400084b0 <rtems_rbheap_free+0xbc> <== ALWAYS TAKEN
40008474: b6 10 00 1d mov %i5, %i3
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
40008478: 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) {
4000847c: 80 a7 60 00 cmp %i5, 0
40008480: 32 bf ff f0 bne,a 40008440 <rtems_rbheap_free+0x4c>
40008484: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
return rtems_rbheap_chunk_of_node(
40008488: 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) {
4000848c: 80 a7 7f f8 cmp %i5, -8
40008490: 02 80 00 06 be 400084a8 <rtems_rbheap_free+0xb4>
40008494: 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);
40008498: c2 06 ff f8 ld [ %i3 + -8 ], %g1
4000849c: 80 a0 60 00 cmp %g1, 0
400084a0: 02 80 00 06 be 400084b8 <rtems_rbheap_free+0xc4>
400084a4: b0 10 20 0e mov 0xe, %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
400084a8: 81 c7 e0 08 ret
400084ac: 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(
400084b0: 10 bf ff f7 b 4000848c <rtems_rbheap_free+0x98>
400084b4: ba 06 ff f8 add %i3, -8, %i5
400084b8: c2 06 ff fc ld [ %i3 + -4 ], %g1
400084bc: 80 a0 60 00 cmp %g1, 0
400084c0: 12 bf ff fa bne 400084a8 <rtems_rbheap_free+0xb4> <== NEVER TAKEN
400084c4: 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(
400084c8: 40 00 07 92 call 4000a310 <_RBTree_Next_unprotected>
400084cc: 90 10 00 1b mov %i3, %o0
400084d0: 92 10 20 01 mov 1, %o1
400084d4: b2 10 00 08 mov %o0, %i1
400084d8: 40 00 07 8e call 4000a310 <_RBTree_Next_unprotected>
400084dc: 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);
400084e0: 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(
400084e4: 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);
400084e8: 94 10 00 1d mov %i5, %o2
400084ec: 7f ff ff 10 call 4000812c <check_and_merge>
400084f0: 90 10 00 1a mov %i2, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
400084f4: c2 06 80 00 ld [ %i2 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
400084f8: f4 26 ff fc st %i2, [ %i3 + -4 ]
before_node = after_node->next;
after_node->next = the_node;
400084fc: fa 26 80 00 st %i5, [ %i2 ]
the_node->next = before_node;
40008500: c2 26 ff f8 st %g1, [ %i3 + -8 ]
before_node->previous = the_node;
40008504: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
40008508: 90 10 00 1a mov %i2, %o0
4000850c: 92 10 00 1c mov %i4, %o1
40008510: 94 10 00 1d mov %i5, %o2
40008514: 96 06 7f f8 add %i1, -8, %o3
40008518: 7f ff ff 05 call 4000812c <check_and_merge>
4000851c: b0 10 20 00 clr %i0
40008520: 81 c7 e0 08 ret
40008524: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
40008528: 81 c7 e0 08 ret <== NOT EXECUTED
4000852c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
400081c4 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
400081c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
400081c8: 80 a6 e0 00 cmp %i3, 0
400081cc: 12 80 00 04 bne 400081dc <rtems_rbheap_initialize+0x18>
400081d0: 82 10 20 0a mov 0xa, %g1
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
400081d4: 81 c7 e0 08 ret
400081d8: 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;
400081dc: 90 10 00 19 mov %i1, %o0
400081e0: 92 10 00 1b mov %i3, %o1
400081e4: 40 00 2f ce call 4001411c <.urem>
400081e8: b4 06 40 1a add %i1, %i2, %i2
if (excess > 0) {
400081ec: 80 a2 20 00 cmp %o0, 0
400081f0: 32 80 00 09 bne,a 40008214 <rtems_rbheap_initialize+0x50>
400081f4: a0 06 40 1b add %i1, %i3, %l0
400081f8: 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) {
400081fc: 80 88 60 ff btst 0xff, %g1
40008200: 12 80 00 0b bne 4000822c <rtems_rbheap_initialize+0x68> <== ALWAYS TAKEN
40008204: a0 10 00 19 mov %i1, %l0
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
40008208: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
4000820c: 81 c7 e0 08 ret
40008210: 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;
40008214: a0 24 00 08 sub %l0, %o0, %l0
40008218: 80 a4 00 19 cmp %l0, %i1
4000821c: 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) {
40008220: 80 88 60 ff btst 0xff, %g1
40008224: 02 bf ff fa be 4000820c <rtems_rbheap_initialize+0x48>
40008228: 82 10 20 09 mov 9, %g1
4000822c: 80 a6 40 1a cmp %i1, %i2
40008230: 1a bf ff f7 bcc 4000820c <rtems_rbheap_initialize+0x48>
40008234: 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;
40008238: 90 10 00 1a mov %i2, %o0
4000823c: 40 00 2f b8 call 4001411c <.urem>
40008240: 92 10 00 1b mov %i3, %o1
return value - excess;
40008244: 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) {
40008248: 80 a4 00 1a cmp %l0, %i2
4000824c: 1a bf ff e2 bcc 400081d4 <rtems_rbheap_initialize+0x10>
40008250: 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 );
40008254: 82 06 20 04 add %i0, 4, %g1
head->next = tail;
40008258: 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 );
4000825c: 82 06 20 0c add %i0, 0xc, %g1
head->next = tail;
head->previous = NULL;
tail->previous = head;
40008260: 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;
40008264: 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 );
40008268: 84 06 20 10 add %i0, 0x10, %g2
4000826c: 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;
40008270: 03 10 00 20 sethi %hi(0x40008000), %g1
40008274: 82 10 60 b4 or %g1, 0xb4, %g1 ! 400080b4 <chunk_compare>
head->next = tail;
head->previous = NULL;
40008278: c0 26 20 04 clr [ %i0 + 4 ]
4000827c: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
tail->previous = head;
40008280: 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;
40008284: c0 26 20 10 clr [ %i0 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40008288: 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;
4000828c: c0 26 20 18 clr [ %i0 + 0x18 ]
the_rbtree->root = NULL;
40008290: c0 26 20 1c clr [ %i0 + 0x1c ]
the_rbtree->first[0] = NULL;
40008294: c0 26 20 20 clr [ %i0 + 0x20 ]
the_rbtree->first[1] = NULL;
40008298: 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;
4000829c: f6 26 20 30 st %i3, [ %i0 + 0x30 ]
control->handler_arg = handler_arg;
400082a0: fa 26 20 38 st %i5, [ %i0 + 0x38 ]
control->extend_descriptors = extend_descriptors;
400082a4: f8 26 20 34 st %i4, [ %i0 + 0x34 ]
first = get_chunk(control);
400082a8: 7f ff ff 87 call 400080c4 <get_chunk>
400082ac: 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;
400082b0: 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) {
400082b4: 80 a2 20 00 cmp %o0, 0
400082b8: 02 bf ff c7 be 400081d4 <rtems_rbheap_initialize+0x10>
400082bc: 92 10 00 08 mov %o0, %o1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
400082c0: c2 06 00 00 ld [ %i0 ], %g1
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
400082c4: 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;
400082c8: e0 22 20 18 st %l0, [ %o0 + 0x18 ]
first->size = aligned_end - aligned_begin;
400082cc: f4 22 20 1c st %i2, [ %o0 + 0x1c ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
400082d0: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
400082d4: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
400082d8: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
400082dc: 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);
400082e0: 92 02 60 08 add %o1, 8, %o1
400082e4: 40 00 07 3c call 40009fd4 <_RBTree_Insert_unprotected>
400082e8: 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;
400082ec: 10 bf ff ba b 400081d4 <rtems_rbheap_initialize+0x10>
400082f0: 82 10 20 00 clr %g1
4001b0e0 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
4001b0e0: 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);
4001b0e4: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
4001b0e8: 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);
4001b0ec: 7f ff fe 32 call 4001a9b4 <rtems_rfs_bitmap_load_map>
4001b0f0: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001b0f4: b0 92 20 00 orcc %o0, 0, %i0
4001b0f8: 24 80 00 04 ble,a 4001b108 <rtems_rfs_bitmap_create_search+0x28>
4001b0fc: de 07 60 14 ld [ %i5 + 0x14 ], %o7
bit++;
map++;
}
return 0;
}
4001b100: 81 c7 e0 08 ret
4001b104: 81 e8 00 00 restore
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
4001b108: f8 07 60 0c ld [ %i5 + 0xc ], %i4
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
4001b10c: c0 27 60 10 clr [ %i5 + 0x10 ]
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001b110: 82 10 3f ff mov -1, %g1
4001b114: c2 23 c0 00 st %g1, [ %o7 ]
4001b118: f4 07 bf fc ld [ %fp + -4 ], %i2
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
4001b11c: 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);
4001b120: 98 10 20 20 mov 0x20, %o4
4001b124: 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)
4001b128: 80 a7 20 00 cmp %i4, 0
4001b12c: 02 80 00 20 be 4001b1ac <rtems_rfs_bitmap_create_search+0xcc><== NEVER TAKEN
4001b130: b6 10 20 01 mov 1, %i3
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
4001b134: 80 a7 20 1f cmp %i4, 0x1f
4001b138: 38 80 00 1f bgu,a 4001b1b4 <rtems_rfs_bitmap_create_search+0xd4>
4001b13c: 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;
4001b140: 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);
4001b144: 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;
4001b148: 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);
4001b14c: 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;
4001b150: 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;
4001b154: 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))
4001b158: 80 a0 e0 00 cmp %g3, 0
4001b15c: 02 80 00 0e be 4001b194 <rtems_rfs_bitmap_create_search+0xb4>
4001b160: 80 a6 60 20 cmp %i1, 0x20
4001b164: 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);
4001b168: 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))
4001b16c: 80 88 80 03 btst %g2, %g3
4001b170: 02 80 00 05 be 4001b184 <rtems_rfs_bitmap_create_search+0xa4>
4001b174: 82 00 60 01 inc %g1
control->free++;
4001b178: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4001b17c: 84 00 a0 01 inc %g2
4001b180: 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++)
4001b184: 80 a1 00 01 cmp %g4, %g1
4001b188: 14 bf ff f9 bg 4001b16c <rtems_rfs_bitmap_create_search+0x8c>
4001b18c: 85 2e c0 01 sll %i3, %g1, %g2
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
4001b190: 80 a6 60 20 cmp %i1, 0x20
4001b194: 02 80 00 0b be 4001b1c0 <rtems_rfs_bitmap_create_search+0xe0>
4001b198: b8 27 00 18 sub %i4, %i0, %i4
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
4001b19c: 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)
4001b1a0: 80 a7 20 00 cmp %i4, 0
4001b1a4: 12 bf ff e4 bne 4001b134 <rtems_rfs_bitmap_create_search+0x54>
4001b1a8: b4 06 a0 04 add %i2, 4, %i2
else
bit++;
map++;
}
return 0;
4001b1ac: 81 c7 e0 08 ret
4001b1b0: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
4001b1b4: b0 10 20 20 mov 0x20, %i0
available = rtems_rfs_bitmap_element_bits ();
4001b1b8: 10 bf ff e8 b 4001b158 <rtems_rfs_bitmap_create_search+0x78>
4001b1bc: 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;
4001b1c0: 82 10 3f ff mov -1, %g1
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
4001b1c4: b2 10 20 00 clr %i1
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001b1c8: c2 23 e0 04 st %g1, [ %o7 + 4 ]
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
4001b1cc: 10 bf ff f5 b 4001b1a0 <rtems_rfs_bitmap_create_search+0xc0>
4001b1d0: 9e 03 e0 04 add %o7, 4, %o7
4001a9b4 <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)
{
4001a9b4: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
4001a9b8: 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)
{
4001a9bc: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
4001a9c0: 80 a0 60 00 cmp %g1, 0
4001a9c4: 02 80 00 0f be 4001aa00 <rtems_rfs_bitmap_load_map+0x4c>
4001a9c8: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
4001a9cc: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
4001a9d0: d4 07 60 08 ld [ %i5 + 8 ], %o2
4001a9d4: d0 07 60 04 ld [ %i5 + 4 ], %o0
4001a9d8: d2 07 40 00 ld [ %i5 ], %o1
4001a9dc: 40 00 07 11 call 4001c620 <rtems_rfs_buffer_handle_request>
4001a9e0: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
4001a9e4: b0 92 20 00 orcc %o0, 0, %i0
4001a9e8: 12 80 00 06 bne 4001aa00 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
4001a9ec: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
4001a9f0: c2 07 40 00 ld [ %i5 ], %g1
4001a9f4: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001a9f8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001a9fc: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
4001aa00: 81 c7 e0 08 ret
4001aa04: 81 e8 00 00 restore
4001aff8 <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)
{
4001aff8: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
4001affc: 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;
4001b000: 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))
4001b004: 80 a7 60 00 cmp %i5, 0
4001b008: 06 80 00 1f bl 4001b084 <rtems_rfs_bitmap_map_alloc+0x8c>
4001b00c: 80 a6 60 00 cmp %i1, 0
4001b010: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001b014: 80 a7 40 01 cmp %i5, %g1
4001b018: 1a 80 00 1b bcc 4001b084 <rtems_rfs_bitmap_map_alloc+0x8c>
4001b01c: 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;
4001b020: fa 26 c0 00 st %i5, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001b024: 90 10 00 18 mov %i0, %o0
4001b028: 92 10 00 1b mov %i3, %o1
4001b02c: 94 10 00 1a mov %i2, %o2
4001b030: 7f ff fe 76 call 4001aa08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001b034: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
4001b038: 80 a2 20 00 cmp %o0, 0
4001b03c: 14 80 00 27 bg 4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001b040: 01 00 00 00 nop
4001b044: c2 0e 80 00 ldub [ %i2 ], %g1
4001b048: 80 a0 60 00 cmp %g1, 0
4001b04c: 12 80 00 23 bne 4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001b050: 80 a6 60 00 cmp %i1, 0
break;
}
if (lower_seed >= 0)
4001b054: 36 80 00 15 bge,a 4001b0a8 <rtems_rfs_bitmap_map_alloc+0xb0>
4001b058: 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)
4001b05c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001b060: 80 a0 40 1d cmp %g1, %i5
4001b064: 38 80 00 02 bgu,a 4001b06c <rtems_rfs_bitmap_map_alloc+0x74>
4001b068: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
4001b06c: 80 a6 60 00 cmp %i1, 0
4001b070: 06 bf ff e5 bl 4001b004 <rtems_rfs_bitmap_map_alloc+0xc>
4001b074: 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))
4001b078: 16 bf ff e6 bge 4001b010 <rtems_rfs_bitmap_map_alloc+0x18><== ALWAYS TAKEN
4001b07c: b2 06 78 00 add %i1, -2048, %i1
|| ((lower_seed >= 0) && (lower_seed < control->size)))
4001b080: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4001b084: 06 80 00 15 bl 4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001b088: 01 00 00 00 nop
4001b08c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001b090: 80 a6 40 01 cmp %i1, %g1
4001b094: 1a 80 00 11 bcc 4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001b098: 80 a0 40 1d cmp %g1, %i5
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
4001b09c: 38 bf ff e2 bgu,a 4001b024 <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
4001b0a0: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
break;
}
if (lower_seed >= 0)
{
*bit = lower_seed;
4001b0a4: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001b0a8: 90 10 00 18 mov %i0, %o0
4001b0ac: 92 10 00 1b mov %i3, %o1
4001b0b0: 94 10 00 1a mov %i2, %o2
4001b0b4: 7f ff fe 55 call 4001aa08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001b0b8: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
4001b0bc: 80 a2 20 00 cmp %o0, 0
4001b0c0: 14 80 00 06 bg 4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001b0c4: 01 00 00 00 nop
4001b0c8: c2 0e 80 00 ldub [ %i2 ], %g1
4001b0cc: 80 a0 60 00 cmp %g1, 0
4001b0d0: 22 bf ff e4 be,a 4001b060 <rtems_rfs_bitmap_map_alloc+0x68>
4001b0d4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
4001b0d8: 81 c7 e0 08 ret
4001b0dc: 91 e8 20 00 restore %g0, 0, %o0
4001ace0 <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);
4001ace0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4001ace4: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
4001ace8: 81 c3 e0 08 retl <== NOT EXECUTED
4001acec: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
4001acf0 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
4001acf0: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = 0;
if (end > start)
4001acf4: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
4001acf8: 08 80 00 06 bleu 4001ad10 <rtems_rfs_bitmap_mask_section+0x20><== NOT EXECUTED
4001acfc: 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);
4001ad00: 92 20 40 09 sub %g1, %o1, %o1 <== NOT EXECUTED
4001ad04: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
4001ad08: 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;
4001ad0c: 91 2a 00 01 sll %o0, %g1, %o0 <== NOT EXECUTED
return mask;
}
4001ad10: 81 c3 e0 08 retl <== NOT EXECUTED
4001b430 <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)
{
4001b430: 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);
4001b434: 96 10 20 01 mov 1, %o3
4001b438: 90 10 00 18 mov %i0, %o0
4001b43c: 92 10 00 19 mov %i1, %o1
4001b440: 40 00 04 78 call 4001c620 <rtems_rfs_buffer_handle_request>
4001b444: 94 10 00 1a mov %i2, %o2
if (rc > 0)
4001b448: 80 a2 20 00 cmp %o0, 0
4001b44c: 24 80 00 04 ble,a 4001b45c <rtems_rfs_block_find_indirect+0x2c><== ALWAYS TAKEN
4001b450: c4 06 60 08 ld [ %i1 + 8 ], %g2
*result = 0;
rc = EIO;
}
return 0;
}
4001b454: 81 c7 e0 08 ret
4001b458: 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);
4001b45c: 83 2e e0 02 sll %i3, 2, %g1
4001b460: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
4001b464: 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);
4001b468: fa 08 c0 01 ldub [ %g3 + %g1 ], %i5
4001b46c: 84 00 c0 01 add %g3, %g1, %g2
4001b470: c2 08 a0 03 ldub [ %g2 + 3 ], %g1
4001b474: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001b478: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
4001b47c: bb 2f 60 18 sll %i5, 0x18, %i5
4001b480: 85 28 a0 08 sll %g2, 8, %g2
4001b484: 87 28 e0 10 sll %g3, 0x10, %g3
4001b488: 82 10 40 1d or %g1, %i5, %g1
4001b48c: 82 10 40 03 or %g1, %g3, %g1
4001b490: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
4001b494: 84 38 00 01 xnor %g0, %g1, %g2
4001b498: 80 a0 00 02 cmp %g0, %g2
4001b49c: 84 60 20 00 subx %g0, 0, %g2
4001b4a0: 82 08 40 02 and %g1, %g2, %g1
4001b4a4: c2 27 00 00 st %g1, [ %i4 ]
if (*result >= rtems_rfs_fs_blocks (fs))
4001b4a8: 80 a1 00 01 cmp %g4, %g1
4001b4ac: 18 bf ff ea bgu 4001b454 <rtems_rfs_block_find_indirect+0x24><== ALWAYS TAKEN
4001b4b0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
4001b4b4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b4b8: 7f ff e2 7b call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001b4bc: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
4001b4c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001b4c4: 32 80 00 06 bne,a 4001b4dc <rtems_rfs_block_find_indirect+0xac><== NOT EXECUTED
4001b4c8: 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;
4001b4cc: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
4001b4d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
4001b4d4: 81 c7 e0 08 ret <== NOT EXECUTED
4001b4d8: 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:"
4001b4dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001b4e0: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001b4e4: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001b4e8: 40 00 22 a5 call 40023f7c <printf> <== NOT EXECUTED
4001b4ec: 90 12 20 38 or %o0, 0x38, %o0 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
4001b4f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001b4f4: 10 bf ff f8 b 4001b4d4 <rtems_rfs_block_find_indirect+0xa4><== NOT EXECUTED
4001b4f8: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
4001b55c <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)
{
4001b55c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
4001b560: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
4001b564: 02 80 00 11 be 4001b5a8 <rtems_rfs_block_get_block_size+0x4c><== NOT EXECUTED
4001b568: 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;
4001b56c: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
4001b570: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001b574: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4001b578: 40 00 56 d4 call 400310c8 <__udivdi3> <== NOT EXECUTED
4001b57c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001b580: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
4001b584: 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;
4001b588: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
4001b58c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001b590: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001b594: 40 00 57 a1 call 40031418 <__umoddi3> <== NOT EXECUTED
4001b598: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001b59c: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
4001b5a0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b5a4: 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;
4001b5a8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
4001b5ac: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
4001b5b0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b5b4: 81 e8 00 00 restore <== NOT EXECUTED
4001b794 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
4001b794: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
4001b798: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
4001b79c: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
4001b7a0: 80 a0 60 00 cmp %g1, 0
4001b7a4: 02 80 00 0b be 4001b7d0 <rtems_rfs_block_map_close+0x3c>
4001b7a8: b0 10 20 00 clr %i0
4001b7ac: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001b7b0: 80 a2 60 00 cmp %o1, 0
4001b7b4: 22 80 00 08 be,a 4001b7d4 <rtems_rfs_block_map_close+0x40><== NEVER TAKEN
4001b7b8: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
4001b7bc: 7f ff da e6 call 40012354 <rtems_rfs_inode_load>
4001b7c0: 90 10 00 1d mov %i5, %o0
if (brc > 0)
4001b7c4: b0 92 20 00 orcc %o0, 0, %i0
4001b7c8: 04 80 00 11 ble 4001b80c <rtems_rfs_block_map_close+0x78> <== ALWAYS TAKEN
4001b7cc: 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);
4001b7d0: 92 06 60 38 add %i1, 0x38, %o1
map->dirty = false;
}
}
map->inode = NULL;
4001b7d4: c0 26 60 04 clr [ %i1 + 4 ]
4001b7d8: 40 00 03 18 call 4001c438 <rtems_rfs_buffer_handle_release>
4001b7dc: 90 10 00 1d mov %i5, %o0
4001b7e0: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
4001b7e4: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
4001b7e8: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
4001b7ec: 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);
4001b7f0: 40 00 03 12 call 4001c438 <rtems_rfs_buffer_handle_release>
4001b7f4: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
4001b7f8: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
4001b7fc: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
4001b800: 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;
}
4001b804: 81 c7 e0 08 ret
4001b808: 81 e8 00 00 restore
int brc;
if (map->dirty && map->inode)
{
brc = rtems_rfs_inode_load (fs, map->inode);
if (brc > 0)
4001b80c: 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);
4001b810: 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]);
4001b814: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001b818: 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);
4001b81c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b820: 86 01 20 06 add %g4, 6, %g3
4001b824: 87 28 e0 02 sll %g3, 2, %g3
4001b828: b6 06 c0 03 add %i3, %g3, %i3
4001b82c: b5 30 a0 18 srl %g2, 0x18, %i2
4001b830: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
4001b834: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b838: b5 30 a0 10 srl %g2, 0x10, %i2
4001b83c: b6 06 c0 03 add %i3, %g3, %i3
4001b840: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
4001b844: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001b848: b5 30 a0 08 srl %g2, 8, %i2
4001b84c: b6 06 c0 03 add %i3, %g3, %i3
4001b850: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
4001b854: f6 00 60 0c ld [ %g1 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001b858: 88 01 20 01 inc %g4
4001b85c: 86 06 c0 03 add %i3, %g3, %g3
4001b860: c4 28 e0 07 stb %g2, [ %g3 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001b864: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
4001b868: b8 07 20 04 add %i4, 4, %i4
4001b86c: 80 a1 20 05 cmp %g4, 5
4001b870: 12 bf ff e9 bne 4001b814 <rtems_rfs_block_map_close+0x80>
4001b874: 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);
4001b878: c4 06 60 04 ld [ %i1 + 4 ], %g2
4001b87c: 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);
4001b880: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001b884: b9 30 e0 18 srl %g3, 0x18, %i4
4001b888: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
4001b88c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001b890: b9 30 e0 10 srl %g3, 0x10, %i4
4001b894: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
4001b898: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001b89c: b9 30 e0 08 srl %g3, 8, %i4
4001b8a0: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
4001b8a4: 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);
4001b8a8: 90 10 00 1d mov %i5, %o0
4001b8ac: 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);
4001b8b0: 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);
4001b8b4: f6 0e 60 0e ldub [ %i1 + 0xe ], %i3
4001b8b8: 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);
4001b8bc: 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);
4001b8c0: c6 06 60 0c ld [ %i1 + 0xc ], %g3
4001b8c4: f6 2f 20 0a stb %i3, [ %i4 + 0xa ]
4001b8c8: 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);
4001b8cc: 94 10 20 01 mov 1, %o2
4001b8d0: 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);
4001b8d4: c6 06 60 04 ld [ %i1 + 4 ], %g3
4001b8d8: 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);
4001b8dc: 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);
4001b8e0: 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);
4001b8e4: 89 30 a0 18 srl %g2, 0x18, %g4
4001b8e8: c8 2f 20 30 stb %g4, [ %i4 + 0x30 ]
4001b8ec: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4001b8f0: b9 30 a0 10 srl %g2, 0x10, %i4
4001b8f4: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
4001b8f8: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4001b8fc: b9 30 a0 08 srl %g2, 8, %i4
4001b900: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
4001b904: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4001b908: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4001b90c: c4 06 60 04 ld [ %i1 + 4 ], %g2
4001b910: 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);
4001b914: 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);
4001b918: 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);
4001b91c: 87 31 20 18 srl %g4, 0x18, %g3
4001b920: c6 2f 20 34 stb %g3, [ %i4 + 0x34 ]
4001b924: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b928: b9 31 20 10 srl %g4, 0x10, %i4
4001b92c: f8 28 e0 35 stb %i4, [ %g3 + 0x35 ]
4001b930: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b934: b9 31 20 08 srl %g4, 8, %i4
4001b938: f8 28 e0 36 stb %i4, [ %g3 + 0x36 ]
4001b93c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001b940: c8 28 e0 37 stb %g4, [ %g3 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001b944: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001b948: 7f ff da e7 call 400124e4 <rtems_rfs_inode_unload>
4001b94c: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
4001b950: c0 2e 40 00 clrb [ %i1 ]
4001b954: 82 38 00 08 xnor %g0, %o0, %g1
4001b958: 83 38 60 1f sra %g1, 0x1f, %g1
4001b95c: 10 bf ff 9d b 4001b7d0 <rtems_rfs_block_map_close+0x3c>
4001b960: b0 0a 00 01 and %o0, %g1, %i0
4001b964 <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)
{
4001b964: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
4001b968: 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))
4001b96c: 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)
{
4001b970: 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))
4001b974: 80 a7 60 00 cmp %i5, 0
4001b978: 02 80 00 05 be 4001b98c <rtems_rfs_block_map_find+0x28>
4001b97c: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001b980: 80 a7 20 00 cmp %i4, 0
4001b984: 02 80 00 4b be 4001bab0 <rtems_rfs_block_map_find+0x14c> <== NEVER TAKEN
4001b988: b0 10 20 06 mov 6, %i0
4001b98c: 80 a7 40 1c cmp %i5, %i4
4001b990: 1a 80 00 48 bcc 4001bab0 <rtems_rfs_block_map_find+0x14c>
4001b994: 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))
4001b998: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4001b99c: 80 a7 40 01 cmp %i5, %g1
4001b9a0: 22 80 00 14 be,a 4001b9f0 <rtems_rfs_block_map_find+0x8c>
4001b9a4: 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)
4001b9a8: 80 a7 20 05 cmp %i4, 5
4001b9ac: 38 80 00 16 bgu,a 4001ba04 <rtems_rfs_block_map_find+0xa0>
4001b9b0: e2 04 20 34 ld [ %l0 + 0x34 ], %l1
{
*block = map->blocks[bpos->bno];
4001b9b4: ba 07 60 08 add %i5, 8, %i5
4001b9b8: bb 2f 60 02 sll %i5, 2, %i5
4001b9bc: ba 06 40 1d add %i1, %i5, %i5
4001b9c0: c2 07 60 04 ld [ %i5 + 4 ], %g1
4001b9c4: c2 26 c0 00 st %g1, [ %i3 ]
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
4001b9c8: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001b9cc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4001b9d0: c4 06 80 00 ld [ %i2 ], %g2
4001b9d4: c6 26 60 18 st %g3, [ %i1 + 0x18 ]
4001b9d8: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
4001b9dc: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
map->bpos.block = *block;
4001b9e0: c2 06 c0 00 ld [ %i3 ], %g1
4001b9e4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
4001b9e8: 81 c7 e0 08 ret
4001b9ec: 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))
4001b9f0: 80 a0 60 00 cmp %g1, 0
4001b9f4: 02 bf ff ee be 4001b9ac <rtems_rfs_block_map_find+0x48>
4001b9f8: 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];
4001b9fc: 10 bf ff f3 b 4001b9c8 <rtems_rfs_block_map_find+0x64>
4001ba00: 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;
4001ba04: 90 10 00 1d mov %i5, %o0
4001ba08: 40 00 52 f3 call 400305d4 <.urem>
4001ba0c: 92 10 00 11 mov %l1, %o1
singly = bpos->bno / fs->blocks_per_block;
4001ba10: 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;
4001ba14: a6 10 00 08 mov %o0, %l3
singly = bpos->bno / fs->blocks_per_block;
4001ba18: 7f ff 9b 22 call 400026a0 <.udiv>
4001ba1c: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
4001ba20: 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;
4001ba24: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
4001ba28: 80 a0 40 1c cmp %g1, %i4
4001ba2c: 1a 80 00 23 bcc 4001bab8 <rtems_rfs_block_map_find+0x154> <== ALWAYS TAKEN
4001ba30: 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;
4001ba34: 40 00 52 e8 call 400305d4 <.urem> <== NOT EXECUTED
4001ba38: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001ba3c: 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;
4001ba40: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
4001ba44: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001ba48: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
4001ba4c: 08 80 00 19 bleu 4001bab0 <rtems_rfs_block_map_find+0x14c><== NOT EXECUTED
4001ba50: 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;
4001ba54: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001ba58: 7f ff 9b 12 call 400026a0 <.udiv> <== NOT EXECUTED
4001ba5c: 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,
4001ba60: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
4001ba64: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
4001ba68: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001ba6c: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
4001ba70: 92 06 60 44 add %i1, 0x44, %o1 <== NOT EXECUTED
4001ba74: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001ba78: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001ba7c: 7f ff fe 6d call 4001b430 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
4001ba80: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
4001ba84: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001ba88: 12 80 00 0a bne 4001bab0 <rtems_rfs_block_map_find+0x14c> <== NOT EXECUTED
4001ba8c: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
4001ba90: 90 10 00 10 mov %l0, %o0
4001ba94: 92 06 60 38 add %i1, 0x38, %o1
4001ba98: 96 10 00 13 mov %l3, %o3
4001ba9c: 7f ff fe 65 call 4001b430 <rtems_rfs_block_find_indirect>
4001baa0: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
4001baa4: b0 92 20 00 orcc %o0, 0, %i0
4001baa8: 22 bf ff c9 be,a 4001b9cc <rtems_rfs_block_map_find+0x68><== ALWAYS TAKEN
4001baac: c6 06 a0 08 ld [ %i2 + 8 ], %g3
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
4001bab0: 81 c7 e0 08 ret
4001bab4: 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,
4001bab8: 82 02 20 08 add %o0, 8, %g1
4001babc: 83 28 60 02 sll %g1, 2, %g1
4001bac0: 82 06 40 01 add %i1, %g1, %g1
4001bac4: 10 bf ff f3 b 4001ba90 <rtems_rfs_block_map_find+0x12c>
4001bac8: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001bb74 <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)
{
4001bb74: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001bb78: 90 10 20 00 clr %o0
4001bb7c: 7f ff e0 ca call 40013ea4 <rtems_rfs_trace>
4001bb80: 13 00 00 08 sethi %hi(0x2000), %o1
4001bb84: 80 8a 20 ff btst 0xff, %o0
4001bb88: 32 80 00 cf bne,a 4001bec4 <rtems_rfs_block_map_grow+0x350><== NEVER TAKEN
4001bb8c: 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))
4001bb90: c4 06 60 08 ld [ %i1 + 8 ], %g2
4001bb94: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
4001bb98: 84 06 80 02 add %i2, %g2, %g2
4001bb9c: 80 a0 80 01 cmp %g2, %g1
4001bba0: 0a 80 00 04 bcs 4001bbb0 <rtems_rfs_block_map_grow+0x3c> <== ALWAYS TAKEN
4001bba4: ba 10 20 1b mov 0x1b, %i5
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
4001bba8: 81 c7 e0 08 ret
4001bbac: 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++)
4001bbb0: 80 a6 a0 00 cmp %i2, 0
4001bbb4: 02 80 00 de be 4001bf2c <rtems_rfs_block_map_grow+0x3b8> <== NEVER TAKEN
4001bbb8: b8 10 20 00 clr %i4
4001bbbc: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001bbc0: a2 10 20 01 mov 1, %l1
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001bbc4: 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,
4001bbc8: 10 80 00 11 b 4001bc0c <rtems_rfs_block_map_grow+0x98>
4001bbcc: 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;
4001bbd0: 82 07 60 08 add %i5, 8, %g1
4001bbd4: 83 28 60 02 sll %g1, 2, %g1
4001bbd8: 82 06 40 01 add %i1, %g1, %g1
4001bbdc: d2 20 60 04 st %o1, [ %g1 + 4 ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
4001bbe0: ba 07 60 01 inc %i5
map->size.offset = 0;
4001bbe4: c0 26 60 0c clr [ %i1 + 0xc ]
if (b == 0)
4001bbe8: 80 a7 20 00 cmp %i4, 0
4001bbec: 12 80 00 03 bne 4001bbf8 <rtems_rfs_block_map_grow+0x84> <== NEVER TAKEN
4001bbf0: fa 26 60 08 st %i5, [ %i1 + 8 ]
*new_block = block;
4001bbf4: d2 26 c0 00 st %o1, [ %i3 ]
map->last_data_block = block;
map->dirty = true;
4001bbf8: 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++)
4001bbfc: b8 07 20 01 inc %i4
4001bc00: 80 a7 00 1a cmp %i4, %i2
4001bc04: 02 80 00 ca be 4001bf2c <rtems_rfs_block_map_grow+0x3b8> <== ALWAYS TAKEN
4001bc08: 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,
4001bc0c: 90 10 00 18 mov %i0, %o0
4001bc10: 94 10 20 00 clr %o2
4001bc14: 7f ff d8 80 call 40011e14 <rtems_rfs_group_bitmap_alloc>
4001bc18: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
4001bc1c: ba 92 20 00 orcc %o0, 0, %i5
4001bc20: 14 bf ff e2 bg 4001bba8 <rtems_rfs_block_map_grow+0x34>
4001bc24: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
4001bc28: fa 06 60 08 ld [ %i1 + 8 ], %i5
4001bc2c: 80 a7 60 04 cmp %i5, 4
4001bc30: 08 bf ff e8 bleu 4001bbd0 <rtems_rfs_block_map_grow+0x5c>
4001bc34: 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;
4001bc38: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
4001bc3c: 90 10 00 1d mov %i5, %o0
4001bc40: 40 00 52 65 call 400305d4 <.urem>
4001bc44: 92 10 00 10 mov %l0, %o1
singly = map->size.count / fs->blocks_per_block;
4001bc48: 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;
4001bc4c: a8 10 00 08 mov %o0, %l4
singly = map->size.count / fs->blocks_per_block;
4001bc50: 7f ff 9a 94 call 400026a0 <.udiv>
4001bc54: 90 10 00 1d mov %i5, %o0
if (map->size.count < fs->block_map_singly_blocks)
4001bc58: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001bc5c: 80 a7 40 01 cmp %i5, %g1
4001bc60: 1a 80 00 31 bcc 4001bd24 <rtems_rfs_block_map_grow+0x1b0> <== NEVER TAKEN
4001bc64: 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) ||
4001bc68: 80 a5 20 00 cmp %l4, 0
4001bc6c: 02 80 00 06 be 4001bc84 <rtems_rfs_block_map_grow+0x110> <== NEVER TAKEN
4001bc70: 80 a5 20 05 cmp %l4, 5
4001bc74: 12 80 00 8a bne 4001be9c <rtems_rfs_block_map_grow+0x328>
4001bc78: 80 a2 20 00 cmp %o0, 0
4001bc7c: 12 80 00 89 bne 4001bea0 <rtems_rfs_block_map_grow+0x32c> <== NEVER TAKEN
4001bc80: 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;
4001bc84: ba 1f 60 05 xor %i5, 5, %i5
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001bc88: 80 a0 00 1d cmp %g0, %i5
&map->singly_buffer,
&map->blocks[singly],
4001bc8c: 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,
4001bc90: 90 10 00 18 mov %i0, %o0
&map->singly_buffer,
&map->blocks[singly],
4001bc94: 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,
4001bc98: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
4001bc9c: 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,
4001bca0: 94 10 00 12 mov %l2, %o2
4001bca4: 96 02 e0 04 add %o3, 4, %o3
4001bca8: 7f ff fd 8f call 4001b2e4 <rtems_rfs_block_map_indirect_alloc>
4001bcac: 98 60 3f ff subx %g0, -1, %o4
4001bcb0: 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)
4001bcb4: 80 a7 60 00 cmp %i5, 0
4001bcb8: 14 80 00 a1 bg 4001bf3c <rtems_rfs_block_map_grow+0x3c8> <== NEVER TAKEN
4001bcbc: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001bcc0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001bcc4: c4 0f bf f8 ldub [ %fp + -8 ], %g2
4001bcc8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001bccc: 91 2d 20 02 sll %l4, 2, %o0
4001bcd0: c4 28 40 08 stb %g2, [ %g1 + %o0 ]
4001bcd4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001bcd8: c4 17 bf f8 lduh [ %fp + -8 ], %g2
4001bcdc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001bce0: 82 00 40 08 add %g1, %o0, %g1
4001bce4: c4 28 60 01 stb %g2, [ %g1 + 1 ]
4001bce8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001bcec: c4 07 bf f8 ld [ %fp + -8 ], %g2
4001bcf0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001bcf4: 85 30 a0 08 srl %g2, 8, %g2
4001bcf8: 82 00 40 08 add %g1, %o0, %g1
4001bcfc: c4 28 60 02 stb %g2, [ %g1 + 2 ]
4001bd00: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001bd04: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001bd08: 90 00 40 08 add %g1, %o0, %o0
4001bd0c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001bd10: c2 2a 20 03 stb %g1, [ %o0 + 3 ]
4001bd14: e2 2e 60 38 stb %l1, [ %i1 + 0x38 ]
4001bd18: fa 06 60 08 ld [ %i1 + 8 ], %i5
4001bd1c: 10 bf ff b1 b 4001bbe0 <rtems_rfs_block_map_grow+0x6c>
4001bd20: 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;
4001bd24: 7f ff 9a 5f call 400026a0 <.udiv> <== NOT EXECUTED
4001bd28: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001bd2c: 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;
4001bd30: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001bd34: 40 00 52 28 call 400305d4 <.urem> <== NOT EXECUTED
4001bd38: 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)
4001bd3c: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
4001bd40: 12 80 00 38 bne 4001be20 <rtems_rfs_block_map_grow+0x2ac> <== NOT EXECUTED
4001bd44: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001bd48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bd4c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001bd50: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001bd54: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
4001bd58: 7f ff fd 63 call 4001b2e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001bd5c: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
4001bd60: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001bd64: 14 80 00 75 bg 4001bf38 <rtems_rfs_block_map_grow+0x3c4> <== NOT EXECUTED
4001bd68: 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) ||
4001bd6c: 02 80 00 06 be 4001bd84 <rtems_rfs_block_map_grow+0x210> <== NOT EXECUTED
4001bd70: 80 a4 20 05 cmp %l0, 5 <== NOT EXECUTED
4001bd74: 12 80 00 5a bne 4001bedc <rtems_rfs_block_map_grow+0x368> <== NOT EXECUTED
4001bd78: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4001bd7c: 12 80 00 59 bne 4001bee0 <rtems_rfs_block_map_grow+0x36c> <== NOT EXECUTED
4001bd80: 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;
4001bd84: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001bd88: 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],
4001bd8c: 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;
4001bd90: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001bd94: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001bd98: 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,
4001bd9c: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001bda0: 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,
4001bda4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bda8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001bdac: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4001bdb0: 7f ff fd 4d call 4001b2e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001bdb4: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
4001bdb8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001bdbc: 14 80 00 54 bg 4001bf0c <rtems_rfs_block_map_grow+0x398> <== NOT EXECUTED
4001bdc0: 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,
4001bdc4: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001bdc8: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
4001bdcc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001bdd0: a1 2c 20 02 sll %l0, 2, %l0 <== NOT EXECUTED
4001bdd4: c4 28 40 10 stb %g2, [ %g1 + %l0 ] <== NOT EXECUTED
4001bdd8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001bddc: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
4001bde0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001bde4: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED
4001bde8: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
4001bdec: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001bdf0: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
4001bdf4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001bdf8: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
4001bdfc: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED
4001be00: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
4001be04: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001be08: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001be0c: a0 00 40 10 add %g1, %l0, %l0 <== NOT EXECUTED
4001be10: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001be14: c2 2c 20 03 stb %g1, [ %l0 + 3 ] <== NOT EXECUTED
4001be18: 10 bf ff aa b 4001bcc0 <rtems_rfs_block_map_grow+0x14c> <== NOT EXECUTED
4001be1c: e2 2e 60 44 stb %l1, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001be20: ac 05 a0 08 add %l6, 8, %l6 <== NOT EXECUTED
4001be24: ad 2d a0 02 sll %l6, 2, %l6 <== NOT EXECUTED
4001be28: ac 06 40 16 add %i1, %l6, %l6 <== NOT EXECUTED
4001be2c: d4 05 a0 04 ld [ %l6 + 4 ], %o2 <== NOT EXECUTED
4001be30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001be34: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001be38: 40 00 01 fa call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001be3c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
4001be40: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001be44: 14 80 00 3d bg 4001bf38 <rtems_rfs_block_map_grow+0x3c4> <== NOT EXECUTED
4001be48: 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,
4001be4c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001be50: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be54: 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,
4001be58: c6 08 80 10 ldub [ %g2 + %l0 ], %g3 <== NOT EXECUTED
4001be5c: 82 00 80 10 add %g2, %l0, %g1 <== NOT EXECUTED
4001be60: d4 08 60 03 ldub [ %g1 + 3 ], %o2 <== NOT EXECUTED
4001be64: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001be68: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001be6c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4001be70: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001be74: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001be78: 94 12 80 03 or %o2, %g3, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be7c: 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,
4001be80: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be84: 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,
4001be88: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be8c: 40 00 01 e5 call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001be90: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
4001be94: 10 bf ff 88 b 4001bcb4 <rtems_rfs_block_map_grow+0x140> <== NOT EXECUTED
4001be98: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be9c: 82 05 60 08 add %l5, 8, %g1
4001bea0: 83 28 60 02 sll %g1, 2, %g1
4001bea4: 82 06 40 01 add %i1, %g1, %g1
4001bea8: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001beac: 90 10 00 18 mov %i0, %o0
4001beb0: 92 10 00 12 mov %l2, %o1
4001beb4: 40 00 01 db call 4001c620 <rtems_rfs_buffer_handle_request>
4001beb8: 96 10 20 01 mov 1, %o3
4001bebc: 10 bf ff 7e b 4001bcb4 <rtems_rfs_block_map_grow+0x140>
4001bec0: 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",
4001bec4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001bec8: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001becc: 40 00 20 2c call 40023f7c <printf> <== NOT EXECUTED
4001bed0: 90 12 20 88 or %o0, 0x88, %o0 ! 40036c88 <CSWTCH.2+0x98> <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001bed4: 10 bf ff 30 b 4001bb94 <rtems_rfs_block_map_grow+0x20> <== NOT EXECUTED
4001bed8: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001bedc: 82 05 a0 08 add %l6, 8, %g1 <== NOT EXECUTED
4001bee0: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001bee4: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001bee8: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
4001beec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bef0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001bef4: 40 00 01 cb call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001bef8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001befc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001bf00: 24 bf ff b2 ble,a 4001bdc8 <rtems_rfs_block_map_grow+0x254><== NOT EXECUTED
4001bf04: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
4001bf08: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4001bf0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bf10: 7f ff d8 50 call 40012050 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001bf14: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
4001bf18: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
4001bf1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bf20: 7f ff d8 4c call 40012050 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001bf24: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001bf28: 30 bf ff 20 b,a 4001bba8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
4001bf2c: ba 10 20 00 clr %i5
}
4001bf30: 81 c7 e0 08 ret
4001bf34: 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);
4001bf38: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
4001bf3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bf40: 7f ff d8 44 call 40012050 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001bf44: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001bf48: 30 bf ff 18 b,a 4001bba8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
4001b2e4 <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)
{
4001b2e4: 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);
4001b2e8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001b2ec: 94 10 20 00 clr %o2
4001b2f0: 90 10 00 18 mov %i0, %o0
4001b2f4: 7f ff da c8 call 40011e14 <rtems_rfs_group_bitmap_alloc>
4001b2f8: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
4001b2fc: ba 92 20 00 orcc %o0, 0, %i5
4001b300: 04 80 00 04 ble 4001b310 <rtems_rfs_block_map_indirect_alloc+0x2c><== ALWAYS TAKEN
4001b304: 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;
}
4001b308: 81 c7 e0 08 ret
4001b30c: 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);
4001b310: 90 10 00 18 mov %i0, %o0
4001b314: 92 10 00 1a mov %i2, %o1
4001b318: 40 00 04 c2 call 4001c620 <rtems_rfs_buffer_handle_request>
4001b31c: 96 10 20 00 clr %o3
if (rc > 0)
4001b320: ba 92 20 00 orcc %o0, 0, %i5
4001b324: 04 80 00 08 ble 4001b344 <rtems_rfs_block_map_indirect_alloc+0x60><== ALWAYS TAKEN
4001b328: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
4001b32c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b330: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001b334: 7f ff db 47 call 40012050 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001b338: 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;
}
4001b33c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b340: 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));
4001b344: c2 06 a0 08 ld [ %i2 + 8 ], %g1
4001b348: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001b34c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001b350: 40 00 22 8d call 40023d84 <memset>
4001b354: 92 10 20 ff mov 0xff, %o1
if (upping)
4001b358: 80 a7 20 00 cmp %i4, 0
4001b35c: 12 80 00 08 bne 4001b37c <rtems_rfs_block_map_indirect_alloc+0x98><== ALWAYS TAKEN
4001b360: 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);
4001b364: 84 10 20 01 mov 1, %g2
4001b368: c4 2e 80 00 stb %g2, [ %i2 ]
*block = new_block;
4001b36c: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
4001b370: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
4001b374: 10 bf ff e5 b 4001b308 <rtems_rfs_block_map_indirect_alloc+0x24>
4001b378: 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))
4001b37c: 90 10 20 00 clr %o0
4001b380: 7f ff e2 c9 call 40013ea4 <rtems_rfs_trace>
4001b384: 13 00 00 08 sethi %hi(0x2000), %o1
4001b388: 80 8a 20 ff btst 0xff, %o0
4001b38c: 32 80 00 24 bne,a 4001b41c <rtems_rfs_block_map_indirect_alloc+0x138><== NEVER TAKEN
4001b390: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001b394: 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)
{
4001b398: 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]);
4001b39c: ba 10 20 01 mov 1, %i5
4001b3a0: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001b3a4: c8 08 a0 24 ldub [ %g2 + 0x24 ], %g4
4001b3a8: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001b3ac: c8 28 c0 01 stb %g4, [ %g3 + %g1 ]
4001b3b0: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001b3b4: c8 10 a0 24 lduh [ %g2 + 0x24 ], %g4
4001b3b8: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001b3bc: 86 00 c0 01 add %g3, %g1, %g3
4001b3c0: c8 28 e0 01 stb %g4, [ %g3 + 1 ]
4001b3c4: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001b3c8: c8 00 a0 24 ld [ %g2 + 0x24 ], %g4
4001b3cc: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001b3d0: 89 31 20 08 srl %g4, 8, %g4
4001b3d4: 86 00 c0 01 add %g3, %g1, %g3
4001b3d8: c8 28 e0 02 stb %g4, [ %g3 + 2 ]
4001b3dc: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001b3e0: c8 00 a0 24 ld [ %g2 + 0x24 ], %g4
4001b3e4: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001b3e8: 84 00 a0 04 add %g2, 4, %g2
4001b3ec: 86 00 c0 01 add %g3, %g1, %g3
4001b3f0: c8 28 e0 03 stb %g4, [ %g3 + 3 ]
4001b3f4: 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++)
4001b3f8: 80 a0 60 14 cmp %g1, 0x14
4001b3fc: 12 bf ff e9 bne 4001b3a0 <rtems_rfs_block_map_indirect_alloc+0xbc>
4001b400: fa 2e 80 00 stb %i5, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
4001b404: 90 06 60 24 add %i1, 0x24, %o0
4001b408: 92 10 20 00 clr %o1
4001b40c: 40 00 22 5e call 40023d84 <memset>
4001b410: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
4001b414: 10 bf ff d4 b 4001b364 <rtems_rfs_block_map_indirect_alloc+0x80>
4001b418: 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",
4001b41c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001b420: 40 00 22 d7 call 40023f7c <printf> <== NOT EXECUTED
4001b424: 90 12 20 00 mov %o0, %o0 ! 40036c00 <CSWTCH.2+0x10> <== NOT EXECUTED
4001b428: 10 bf ff dc b 4001b398 <rtems_rfs_block_map_indirect_alloc+0xb4><== NOT EXECUTED
4001b42c: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
4001b230 <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)
{
4001b230: 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) ||
4001b234: 80 a7 20 00 cmp %i4, 0
4001b238: 22 80 00 07 be,a 4001b254 <rtems_rfs_block_map_indirect_shrink+0x24><== NEVER TAKEN
4001b23c: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
4001b240: 80 a7 20 05 cmp %i4, 5
4001b244: 02 80 00 11 be 4001b288 <rtems_rfs_block_map_indirect_shrink+0x58>
4001b248: 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;
4001b24c: 81 c7 e0 08 ret
4001b250: 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];
4001b254: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
4001b258: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
4001b25c: f4 06 e0 04 ld [ %i3 + 4 ], %i2 <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
4001b260: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001b264: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b268: 92 10 20 00 clr %o1
4001b26c: 7f ff db 79 call 40012050 <rtems_rfs_group_bitmap_free>
4001b270: 94 10 00 1a mov %i2, %o2
if (rc > 0)
4001b274: b0 92 20 00 orcc %o0, 0, %i0
4001b278: 24 80 00 02 ble,a 4001b280 <rtems_rfs_block_map_indirect_shrink+0x50><== ALWAYS TAKEN
4001b27c: f4 26 60 1c st %i2, [ %i1 + 0x1c ]
map->last_map_block = block_to_free;
}
return rc;
}
4001b280: 81 c7 e0 08 ret
4001b284: 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) ||
4001b288: 12 bf ff f1 bne 4001b24c <rtems_rfs_block_map_indirect_shrink+0x1c><== NEVER TAKEN
4001b28c: 84 10 20 00 clr %g2
4001b290: 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];
4001b294: f4 06 60 24 ld [ %i1 + 0x24 ], %i2
4001b298: 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);
4001b29c: c8 08 40 00 ldub [ %g1 ], %g4
4001b2a0: f6 08 60 01 ldub [ %g1 + 1 ], %i3
4001b2a4: f8 08 60 03 ldub [ %g1 + 3 ], %i4
4001b2a8: 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,
4001b2ac: 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);
4001b2b0: 89 29 20 18 sll %g4, 0x18, %g4
4001b2b4: b7 2e e0 10 sll %i3, 0x10, %i3
4001b2b8: bb 2f 60 08 sll %i5, 8, %i5
4001b2bc: 88 11 00 1b or %g4, %i3, %g4
4001b2c0: 88 11 00 1c or %g4, %i4, %g4
4001b2c4: 88 11 00 1d or %g4, %i5, %g4
4001b2c8: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
4001b2cc: 84 00 a0 04 add %g2, 4, %g2
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001b2d0: 80 a0 a0 14 cmp %g2, 0x14
4001b2d4: 12 bf ff f2 bne 4001b29c <rtems_rfs_block_map_indirect_shrink+0x6c>
4001b2d8: 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);
4001b2dc: 10 bf ff e3 b 4001b268 <rtems_rfs_block_map_indirect_shrink+0x38>
4001b2e0: 90 10 00 18 mov %i0, %o0
4001b610 <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)
{
4001b610: 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;
4001b614: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
4001b618: 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;
4001b61c: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
4001b620: 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;
4001b624: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
4001b628: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
4001b62c: 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;
4001b630: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
4001b634: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
4001b638: 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;
4001b63c: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
4001b640: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
4001b644: 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);
4001b648: 90 10 00 18 mov %i0, %o0
4001b64c: 92 10 00 19 mov %i1, %o1
4001b650: 7f ff db 41 call 40012354 <rtems_rfs_inode_load>
4001b654: ba 10 00 1a mov %i2, %i5
if (rc > 0)
4001b658: b8 92 20 00 orcc %o0, 0, %i4
4001b65c: 14 80 00 3f bg 4001b758 <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
4001b660: 88 10 00 1a mov %i2, %g4
4001b664: 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;
4001b668: f2 26 a0 04 st %i1, [ %i2 + 4 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001b66c: 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]);
4001b670: b8 00 60 06 add %g1, 6, %i4
4001b674: b9 2f 20 02 sll %i4, 2, %i4
4001b678: b8 00 c0 1c add %g3, %i4, %i4
4001b67c: de 0f 20 04 ldub [ %i4 + 4 ], %o7
4001b680: f4 0f 20 05 ldub [ %i4 + 5 ], %i2
4001b684: f6 0f 20 07 ldub [ %i4 + 7 ], %i3
4001b688: f8 0f 20 06 ldub [ %i4 + 6 ], %i4
4001b68c: 85 2b e0 18 sll %o7, 0x18, %g2
4001b690: b5 2e a0 10 sll %i2, 0x10, %i2
4001b694: b9 2f 20 08 sll %i4, 8, %i4
4001b698: 84 10 80 1a or %g2, %i2, %g2
4001b69c: 84 10 80 1b or %g2, %i3, %g2
4001b6a0: 84 10 80 1c or %g2, %i4, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
4001b6a4: 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++)
4001b6a8: 82 00 60 01 inc %g1
4001b6ac: 80 a0 60 05 cmp %g1, 5
4001b6b0: 12 bf ff f0 bne 4001b670 <rtems_rfs_block_map_open+0x60>
4001b6b4: 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);
4001b6b8: c8 08 e0 0f ldub [ %g3 + 0xf ], %g4
4001b6bc: c2 08 e0 0c ldub [ %g3 + 0xc ], %g1
4001b6c0: f8 08 e0 0d ldub [ %g3 + 0xd ], %i4
4001b6c4: c4 08 e0 0e ldub [ %g3 + 0xe ], %g2
4001b6c8: b9 2f 20 10 sll %i4, 0x10, %i4
4001b6cc: 85 28 a0 08 sll %g2, 8, %g2
4001b6d0: 83 28 60 18 sll %g1, 0x18, %g1
4001b6d4: 82 10 40 1c or %g1, %i4, %g1
4001b6d8: 82 10 40 04 or %g1, %g4, %g1
4001b6dc: 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);
4001b6e0: c2 27 60 08 st %g1, [ %i5 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
4001b6e4: 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);
4001b6e8: c2 08 e0 0a ldub [ %g3 + 0xa ], %g1
4001b6ec: 83 28 60 08 sll %g1, 8, %g1
4001b6f0: 82 10 80 01 or %g2, %g1, %g1
4001b6f4: 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);
4001b6f8: c8 08 e0 33 ldub [ %g3 + 0x33 ], %g4
4001b6fc: c2 08 e0 30 ldub [ %g3 + 0x30 ], %g1
4001b700: f8 08 e0 31 ldub [ %g3 + 0x31 ], %i4
4001b704: c4 08 e0 32 ldub [ %g3 + 0x32 ], %g2
4001b708: b9 2f 20 10 sll %i4, 0x10, %i4
4001b70c: 85 28 a0 08 sll %g2, 8, %g2
4001b710: 83 28 60 18 sll %g1, 0x18, %g1
4001b714: 82 10 40 1c or %g1, %i4, %g1
4001b718: 82 10 40 04 or %g1, %g4, %g1
4001b71c: 82 10 40 02 or %g1, %g2, %g1
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
4001b720: 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);
4001b724: c2 08 e0 34 ldub [ %g3 + 0x34 ], %g1
4001b728: c8 08 e0 37 ldub [ %g3 + 0x37 ], %g4
4001b72c: c4 08 e0 36 ldub [ %g3 + 0x36 ], %g2
4001b730: f8 08 e0 35 ldub [ %g3 + 0x35 ], %i4
4001b734: 83 28 60 18 sll %g1, 0x18, %g1
4001b738: 87 2f 20 10 sll %i4, 0x10, %g3
4001b73c: 85 28 a0 08 sll %g2, 8, %g2
4001b740: 82 10 40 03 or %g1, %g3, %g1
4001b744: 82 10 40 04 or %g1, %g4, %g1
4001b748: 82 10 40 02 or %g1, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
4001b74c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
4001b750: 7f ff db 65 call 400124e4 <rtems_rfs_inode_unload>
4001b754: 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);
4001b758: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
4001b75c: 40 00 03 37 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001b760: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001b764: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001b768: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
4001b76c: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
4001b770: 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);
4001b774: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
4001b778: 40 00 03 30 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001b77c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
handle->dirty = false;
4001b780: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
4001b784: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
4001b788: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
4001b78c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b790: 81 e8 00 00 restore <== NOT EXECUTED
4001bf4c <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
4001bf4c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
4001bf50: 90 10 20 00 clr %o0
4001bf54: 13 00 00 10 sethi %hi(0x4000), %o1
4001bf58: 7f ff df d3 call 40013ea4 <rtems_rfs_trace>
4001bf5c: b6 10 00 18 mov %i0, %i3
4001bf60: 80 8a 20 ff btst 0xff, %o0
4001bf64: 32 80 00 b0 bne,a 4001c224 <rtems_rfs_block_map_shrink+0x2d8><== NEVER TAKEN
4001bf68: 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)
4001bf6c: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001bf70: 80 a7 20 00 cmp %i4, 0
4001bf74: 02 80 00 a9 be 4001c218 <rtems_rfs_block_map_shrink+0x2cc>
4001bf78: 80 a6 80 1c cmp %i2, %i4
4001bf7c: 38 80 00 02 bgu,a 4001bf84 <rtems_rfs_block_map_shrink+0x38><== NEVER TAKEN
4001bf80: b4 10 00 1c mov %i4, %i2 <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001bf84: 80 a6 a0 00 cmp %i2, 0
4001bf88: 02 80 00 98 be 4001c1e8 <rtems_rfs_block_map_shrink+0x29c><== NEVER TAKEN
4001bf8c: 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,
4001bf90: 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;
4001bf94: 10 80 00 14 b 4001bfe4 <rtems_rfs_block_map_shrink+0x98>
4001bf98: 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];
4001bf9c: b9 2f 20 02 sll %i4, 2, %i4
4001bfa0: b8 06 40 1c add %i1, %i4, %i4
4001bfa4: fa 07 20 04 ld [ %i4 + 4 ], %i5
map->blocks[block] = 0;
4001bfa8: c0 27 20 04 clr [ %i4 + 4 ]
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001bfac: 90 10 00 1b mov %i3, %o0
4001bfb0: 92 10 20 00 clr %o1
4001bfb4: 7f ff d8 27 call 40012050 <rtems_rfs_group_bitmap_free>
4001bfb8: 94 10 00 1d mov %i5, %o2
if (rc > 0)
4001bfbc: 80 a2 20 00 cmp %o0, 0
4001bfc0: 14 80 00 63 bg 4001c14c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001bfc4: b4 86 bf ff addcc %i2, -1, %i2
return rc;
map->size.count--;
4001bfc8: f8 06 60 08 ld [ %i1 + 8 ], %i4
map->size.offset = 0;
4001bfcc: 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--;
4001bfd0: b8 07 3f ff add %i4, -1, %i4
map->size.offset = 0;
map->last_data_block = block_to_free;
4001bfd4: 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--;
4001bfd8: f8 26 60 08 st %i4, [ %i1 + 8 ]
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001bfdc: 02 80 00 80 be 4001c1dc <rtems_rfs_block_map_shrink+0x290>
4001bfe0: 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;
4001bfe4: ba 07 3f ff add %i4, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
4001bfe8: 80 a7 60 04 cmp %i5, 4
4001bfec: 28 bf ff ec bleu,a 4001bf9c <rtems_rfs_block_map_shrink+0x50>
4001bff0: 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;
4001bff4: f0 06 e0 34 ld [ %i3 + 0x34 ], %i0
4001bff8: 90 10 00 1d mov %i5, %o0
4001bffc: 40 00 51 76 call 400305d4 <.urem>
4001c000: 92 10 00 18 mov %i0, %o1
singly = block / fs->blocks_per_block;
4001c004: 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;
4001c008: a0 10 00 08 mov %o0, %l0
singly = block / fs->blocks_per_block;
4001c00c: 7f ff 99 a5 call 400026a0 <.udiv>
4001c010: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
4001c014: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1
4001c018: 80 a7 40 01 cmp %i5, %g1
4001c01c: 0a 80 00 4e bcs 4001c154 <rtems_rfs_block_map_shrink+0x208><== ALWAYS TAKEN
4001c020: 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)
4001c024: c2 06 e0 3c ld [ %i3 + 0x3c ], %g1 <== NOT EXECUTED
4001c028: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4001c02c: 1a 80 00 6d bcc 4001c1e0 <rtems_rfs_block_map_shrink+0x294><== NOT EXECUTED
4001c030: 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;
4001c034: 7f ff 99 9b call 400026a0 <.udiv> <== NOT EXECUTED
4001c038: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001c03c: 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;
4001c040: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001c044: 40 00 51 64 call 400305d4 <.urem> <== NOT EXECUTED
4001c048: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001c04c: 82 07 20 08 add %i4, 8, %g1 <== NOT EXECUTED
4001c050: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001c054: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001c058: 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;
4001c05c: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001c060: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001c064: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001c068: 40 00 01 6e call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001c06c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001c070: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c074: 14 80 00 36 bg 4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001c078: 85 2d 20 02 sll %l4, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001c07c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001c080: 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,
4001c084: 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,
4001c088: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001c08c: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3 <== NOT EXECUTED
4001c090: ea 08 60 03 ldub [ %g1 + 3 ], %l5 <== NOT EXECUTED
4001c094: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001c098: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001c09c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4001c0a0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001c0a4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001c0a8: 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,
4001c0ac: 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,
4001c0b0: 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,
4001c0b4: 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,
4001c0b8: 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,
4001c0bc: 40 00 01 59 call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001c0c0: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
4001c0c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c0c8: 14 80 00 21 bg 4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001c0cc: 85 2c 20 02 sll %l0, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001c0d0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
4001c0d4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
4001c0d8: 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,
4001c0dc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001c0e0: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3 <== NOT EXECUTED
4001c0e4: fa 08 60 03 ldub [ %g1 + 3 ], %i5 <== NOT EXECUTED
4001c0e8: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001c0ec: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001c0f0: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4001c0f4: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001c0f8: ba 17 40 03 or %i5, %g3, %i5 <== NOT EXECUTED
4001c0fc: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001c100: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
4001c104: 12 bf ff aa bne 4001bfac <rtems_rfs_block_map_shrink+0x60><== NOT EXECUTED
4001c108: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
4001c10c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001c110: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001c114: 7f ff d7 cf call 40012050 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001c118: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
if (rc > 0)
4001c11c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c120: 14 80 00 0b bg 4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001c124: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
4001c128: ea 26 60 1c st %l5, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001c12c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001c130: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4001c134: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4001c138: 7f ff fc 3e call 4001b230 <rtems_rfs_block_map_indirect_shrink><== NOT EXECUTED
4001c13c: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
4001c140: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c144: 22 bf ff 9b be,a 4001bfb0 <rtems_rfs_block_map_shrink+0x64><== NOT EXECUTED
4001c148: 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;
}
4001c14c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c150: 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,
4001c154: 82 02 20 08 add %o0, 8, %g1
4001c158: 83 28 60 02 sll %g1, 2, %g1
4001c15c: 82 06 40 01 add %i1, %g1, %g1
4001c160: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001c164: 90 10 00 1b mov %i3, %o0
4001c168: 92 10 00 12 mov %l2, %o1
4001c16c: 40 00 01 2d call 4001c620 <rtems_rfs_buffer_handle_request>
4001c170: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
4001c174: 80 a2 20 00 cmp %o0, 0
4001c178: 14 bf ff f5 bg 4001c14c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001c17c: 85 2c 20 02 sll %l0, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001c180: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001c184: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c188: 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,
4001c18c: 82 00 c0 02 add %g3, %g2, %g1
4001c190: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3
4001c194: fa 08 60 03 ldub [ %g1 + 3 ], %i5
4001c198: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001c19c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001c1a0: 87 28 e0 18 sll %g3, 0x18, %g3
4001c1a4: 85 28 a0 10 sll %g2, 0x10, %g2
4001c1a8: 83 28 60 08 sll %g1, 8, %g1
4001c1ac: ba 17 40 03 or %i5, %g3, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c1b0: 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,
4001c1b4: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c1b8: 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,
4001c1bc: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c1c0: 96 10 00 14 mov %l4, %o3
4001c1c4: 7f ff fc 1b call 4001b230 <rtems_rfs_block_map_indirect_shrink>
4001c1c8: 98 10 00 10 mov %l0, %o4
singly, direct);
if (rc)
4001c1cc: 80 a2 20 00 cmp %o0, 0
4001c1d0: 22 bf ff 78 be,a 4001bfb0 <rtems_rfs_block_map_shrink+0x64><== ALWAYS TAKEN
4001c1d4: 90 10 00 1b mov %i3, %o0
4001c1d8: 30 bf ff dd b,a 4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
4001c1dc: 80 a7 20 00 cmp %i4, 0
4001c1e0: 22 80 00 17 be,a 4001c23c <rtems_rfs_block_map_shrink+0x2f0>
4001c1e4: c0 26 60 1c clr [ %i1 + 0x1c ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
4001c1e8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4001c1ec: 80 a0 80 1c cmp %g2, %i4
4001c1f0: 1a 80 00 14 bcc 4001c240 <rtems_rfs_block_map_shrink+0x2f4><== NEVER TAKEN
4001c1f4: 82 07 3f ff add %i4, -1, %g1
4001c1f8: 80 a0 40 02 cmp %g1, %g2
4001c1fc: 12 80 00 08 bne 4001c21c <rtems_rfs_block_map_shrink+0x2d0><== NEVER TAKEN
4001c200: 90 10 20 00 clr %o0
4001c204: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4001c208: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
4001c20c: 80 a0 80 01 cmp %g2, %g1
4001c210: 38 80 00 0e bgu,a 4001c248 <rtems_rfs_block_map_shrink+0x2fc><== ALWAYS TAKEN
4001c214: 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;
4001c218: 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;
}
4001c21c: 81 c7 e0 08 ret
4001c220: 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",
4001c224: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c228: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c22c: 40 00 1f 54 call 40023f7c <printf> <== NOT EXECUTED
4001c230: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40036cc0 <CSWTCH.2+0xd0> <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
4001c234: 10 bf ff 4f b 4001bf70 <rtems_rfs_block_map_shrink+0x24> <== NOT EXECUTED
4001c238: 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;
4001c23c: c0 26 60 20 clr [ %i1 + 0x20 ]
4001c240: 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);
4001c244: f8 26 60 10 st %i4, [ %i1 + 0x10 ]
4001c248: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
4001c24c: 80 a0 60 00 cmp %g1, 0
4001c250: 02 bf ff f2 be 4001c218 <rtems_rfs_block_map_shrink+0x2cc><== ALWAYS TAKEN
4001c254: c0 26 60 18 clr [ %i1 + 0x18 ]
4001c258: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
return 0;
4001c25c: 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);
4001c260: f8 26 60 10 st %i4, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
}
4001c264: 81 c7 e0 08 ret <== NOT EXECUTED
4001c268: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400224b8 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
400224b8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
400224bc: 90 10 20 00 clr %o0
400224c0: 7f ff c6 79 call 40013ea4 <rtems_rfs_trace>
400224c4: 92 10 20 40 mov 0x40, %o1
400224c8: 80 8a 20 ff btst 0xff, %o0
400224cc: 02 80 00 0b be 400224f8 <rtems_rfs_buffer_bdbuf_release+0x40><== ALWAYS TAKEN
400224d0: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
400224d4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
400224d8: 12 80 00 18 bne 40022538 <rtems_rfs_buffer_bdbuf_release+0x80><== NOT EXECUTED
400224dc: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
400224e0: 17 10 00 d0 sethi %hi(0x40034000), %o3 <== NOT EXECUTED
400224e4: 96 12 e2 10 or %o3, 0x210, %o3 ! 40034210 <__FUNCTION__.6193+0x148><== NOT EXECUTED
400224e8: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
400224ec: 40 00 06 a4 call 40023f7c <printf> <== NOT EXECUTED
400224f0: 90 12 23 30 or %o0, 0x330, %o0 ! 40038330 <rtems_rfs_rtems_file_handlers+0x3c><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
400224f4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400224f8: 02 80 00 09 be 4002251c <rtems_rfs_buffer_bdbuf_release+0x64>
400224fc: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
40022500: 7f ff d0 29 call 400165a4 <rtems_bdbuf_release_modified>
40022504: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
40022508: 80 a0 00 08 cmp %g0, %o0
4002250c: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
40022510: b0 0e 20 05 and %i0, 5, %i0
40022514: 81 c7 e0 08 ret
40022518: 81 e8 00 00 restore
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
4002251c: 7f ff cf ea call 400164c4 <rtems_bdbuf_release>
40022520: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
40022524: 80 a0 00 08 cmp %g0, %o0
40022528: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
4002252c: b0 0e 20 05 and %i0, 5, %i0
40022530: 81 c7 e0 08 ret
40022534: 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",
40022538: 17 10 00 e0 sethi %hi(0x40038000), %o3 <== NOT EXECUTED
4002253c: 10 bf ff eb b 400224e8 <rtems_rfs_buffer_bdbuf_release+0x30><== NOT EXECUTED
40022540: 96 12 e3 20 or %o3, 0x320, %o3 ! 40038320 <rtems_rfs_rtems_file_handlers+0x2c><== NOT EXECUTED
40022544: 40 02 27 e8 call 400ac4e4 <__end+0x61b94> <== NOT EXECUTED
40022548: 40 02 27 54 call 400ac298 <__end+0x61948> <== NOT EXECUTED
4002254c: 40 02 27 48 call 400ac26c <__end+0x6191c> <== NOT EXECUTED
40022550: 40 02 27 3c call 400ac240 <__end+0x618f0> <== NOT EXECUTED
40022554: 40 02 27 30 call 400ac214 <__end+0x618c4> <== NOT EXECUTED
40022558: 40 02 27 28 call 400ac1f8 <__end+0x618a8> <== NOT EXECUTED
4002255c: 40 02 27 1c call 400ac1cc <__end+0x6187c> <== NOT EXECUTED
40022560: 40 02 27 10 call 400ac1a0 <__end+0x61850> <== NOT EXECUTED
40022564: 40 02 27 04 call 400ac174 <__end+0x61824> <== NOT EXECUTED
40022568: 40 02 26 fc call 400ac158 <__end+0x61808> <== NOT EXECUTED
4002256c: 40 02 26 f0 call 400ac12c <__end+0x617dc> <== NOT EXECUTED
40022570: 40 02 26 e4 call 400ac100 <__end+0x617b0> <== NOT EXECUTED
40022574: 40 02 26 d8 call 400ac0d4 <__end+0x61784> <== NOT EXECUTED
4001ccf0 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
4001ccf0: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001ccf4: 90 10 20 00 clr %o0
4001ccf8: 92 10 20 10 mov 0x10, %o1
4001ccfc: 7f ff dc 6a call 40013ea4 <rtems_rfs_trace>
4001cd00: ba 10 00 18 mov %i0, %i5
4001cd04: 80 8a 20 ff btst 0xff, %o0
4001cd08: 12 80 00 15 bne 4001cd5c <rtems_rfs_buffer_close+0x6c> <== NEVER TAKEN
4001cd0c: 11 10 00 dc sethi %hi(0x40037000), %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));
4001cd10: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4001cd14: 90 10 00 1d mov %i5, %o0
4001cd18: 7f ff ff ad call 4001cbcc <rtems_rfs_buffer_setblksize>
4001cd1c: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001cd20: b0 92 20 00 orcc %o0, 0, %i0
4001cd24: 04 80 00 07 ble 4001cd40 <rtems_rfs_buffer_close+0x50> <== ALWAYS TAKEN
4001cd28: 90 10 20 00 clr %o0
4001cd2c: 7f ff dc 5e call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001cd30: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
4001cd34: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cd38: 12 80 00 1f bne 4001cdb4 <rtems_rfs_buffer_close+0xc4> <== NOT EXECUTED
4001cd3c: 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)
4001cd40: 7f ff ac 60 call 40007ec0 <close>
4001cd44: d0 07 60 0c ld [ %i5 + 0xc ], %o0
4001cd48: 80 a2 20 00 cmp %o0, 0
4001cd4c: 06 80 00 08 bl 4001cd6c <rtems_rfs_buffer_close+0x7c> <== NEVER TAKEN
4001cd50: 01 00 00 00 nop
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
rc, strerror (rc));
}
return rc;
}
4001cd54: 81 c7 e0 08 ret
4001cd58: 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");
4001cd5c: 40 00 1d 20 call 400241dc <puts> <== NOT EXECUTED
4001cd60: 90 12 21 98 or %o0, 0x198, %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));
4001cd64: 10 bf ff ec b 4001cd14 <rtems_rfs_buffer_close+0x24> <== NOT EXECUTED
4001cd68: 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;
4001cd6c: 40 00 16 f3 call 40022938 <__errno> <== NOT EXECUTED
4001cd70: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001cd74: 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;
4001cd78: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001cd7c: 7f ff dc 4a call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001cd80: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001cd84: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cd88: 02 80 00 09 be 4001cdac <rtems_rfs_buffer_close+0xbc> <== NOT EXECUTED
4001cd8c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
4001cd90: 40 00 20 c5 call 400250a4 <strerror> <== NOT EXECUTED
4001cd94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cd98: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001cd9c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001cda0: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001cda4: 40 00 1c 76 call 40023f7c <printf> <== NOT EXECUTED
4001cda8: 90 12 22 00 or %o0, 0x200, %o0 ! 40037200 <CSWTCH.2+0x610><== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
4001cdac: 81 c7 e0 08 ret <== NOT EXECUTED
4001cdb0: 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",
4001cdb4: 40 00 20 bc call 400250a4 <strerror> <== NOT EXECUTED
4001cdb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cdbc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001cdc0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001cdc4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001cdc8: 40 00 1c 6d call 40023f7c <printf> <== NOT EXECUTED
4001cdcc: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 400371c0 <CSWTCH.2+0x5d0><== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
4001cdd0: 7f ff ac 3c call 40007ec0 <close> <== NOT EXECUTED
4001cdd4: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
4001cdd8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001cddc: 16 bf ff f4 bge 4001cdac <rtems_rfs_buffer_close+0xbc> <== NOT EXECUTED
4001cde0: 01 00 00 00 nop <== NOT EXECUTED
4001cde4: 30 bf ff e2 b,a 4001cd6c <rtems_rfs_buffer_close+0x7c> <== NOT EXECUTED
4001c438 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
4001c438: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
4001c43c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001c440: 80 a0 60 00 cmp %g1, 0
4001c444: 02 80 00 13 be 4001c490 <rtems_rfs_buffer_handle_release+0x58>
4001c448: b8 10 20 00 clr %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001c44c: 90 10 20 00 clr %o0
4001c450: 7f ff de 95 call 40013ea4 <rtems_rfs_trace>
4001c454: 92 10 22 00 mov 0x200, %o1
4001c458: 80 8a 20 ff btst 0xff, %o0
4001c45c: 32 80 00 0f bne,a 4001c498 <rtems_rfs_buffer_handle_release+0x60><== NEVER TAKEN
4001c460: 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)
4001c464: d0 06 60 08 ld [ %i1 + 8 ], %o0
4001c468: fa 02 20 30 ld [ %o0 + 0x30 ], %i5
4001c46c: 80 a7 60 00 cmp %i5, 0
4001c470: 04 80 00 05 ble 4001c484 <rtems_rfs_buffer_handle_release+0x4c><== NEVER TAKEN
4001c474: 01 00 00 00 nop
rtems_rfs_buffer_refs_down (handle);
4001c478: ba 07 7f ff add %i5, -1, %i5
4001c47c: fa 22 20 30 st %i5, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
4001c480: 80 a7 60 00 cmp %i5, 0
4001c484: 02 80 00 15 be 4001c4d8 <rtems_rfs_buffer_handle_release+0xa0>
4001c488: b8 10 20 00 clr %i4
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
4001c48c: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
4001c490: 81 c7 e0 08 ret
4001c494: 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",
4001c498: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001c49c: 12 80 00 28 bne 4001c53c <rtems_rfs_buffer_handle_release+0x104><== NOT EXECUTED
4001c4a0: 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" : "");
4001c4a4: 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",
4001c4a8: 15 10 00 d0 sethi %hi(0x40034000), %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" : "");
4001c4ac: 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",
4001c4b0: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4001c4b4: 12 80 00 28 bne 4001c554 <rtems_rfs_buffer_handle_release+0x11c><== NOT EXECUTED
4001c4b8: 94 12 a2 10 or %o2, 0x210, %o2 <== NOT EXECUTED
4001c4bc: 19 10 00 db sethi %hi(0x40036c00), %o4 <== NOT EXECUTED
4001c4c0: 98 13 21 90 or %o4, 0x190, %o4 ! 40036d90 <CSWTCH.2+0x1a0><== NOT EXECUTED
4001c4c4: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c4c8: 40 00 1e ad call 40023f7c <printf> <== NOT EXECUTED
4001c4cc: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 40036da0 <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)
4001c4d0: 10 bf ff e6 b 4001c468 <rtems_rfs_buffer_handle_release+0x30><== NOT EXECUTED
4001c4d4: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
4001c4d8: 7f ff f3 61 call 4001925c <_Chain_Extract>
4001c4dc: 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--;
4001c4e0: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
if (rtems_rfs_fs_no_local_cache (fs))
4001c4e4: 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--;
4001c4e8: 84 00 bf ff add %g2, -1, %g2
if (rtems_rfs_fs_no_local_cache (fs))
4001c4ec: 80 88 60 02 btst 2, %g1
4001c4f0: 12 80 00 1c bne 4001c560 <rtems_rfs_buffer_handle_release+0x128>
4001c4f4: 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 +
4001c4f8: c6 06 20 70 ld [ %i0 + 0x70 ], %g3
4001c4fc: c4 06 20 60 ld [ %i0 + 0x60 ], %g2
4001c500: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4001c504: 84 00 c0 02 add %g3, %g2, %g2
4001c508: 80 a0 80 01 cmp %g2, %g1
4001c50c: 1a 80 00 21 bcc 4001c590 <rtems_rfs_buffer_handle_release+0x158>
4001c510: 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))
4001c514: c2 0e 40 00 ldub [ %i1 ], %g1
4001c518: 80 a0 60 00 cmp %g1, 0
4001c51c: 02 80 00 17 be 4001c578 <rtems_rfs_buffer_handle_release+0x140>
4001c520: 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 );
4001c524: 7f ff c4 c2 call 4000d82c <_Chain_Append>
4001c528: 90 06 20 64 add %i0, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
4001c52c: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
4001c530: 82 00 60 01 inc %g1
4001c534: 10 bf ff d6 b 4001c48c <rtems_rfs_buffer_handle_release+0x54>
4001c538: 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" : "");
4001c53c: 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",
4001c540: 15 10 00 db sethi %hi(0x40036c00), %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" : "");
4001c544: 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",
4001c548: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4001c54c: 02 bf ff dc be 4001c4bc <rtems_rfs_buffer_handle_release+0x84><== NOT EXECUTED
4001c550: 94 12 a1 88 or %o2, 0x188, %o2 <== NOT EXECUTED
4001c554: 19 10 00 d0 sethi %hi(0x40034000), %o4 <== NOT EXECUTED
4001c558: 10 bf ff db b 4001c4c4 <rtems_rfs_buffer_handle_release+0x8c><== NOT EXECUTED
4001c55c: 98 13 22 10 or %o4, 0x210, %o4 ! 40034210 <__FUNCTION__.6193+0x148><== 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;
4001c560: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
4001c564: d2 0e 40 00 ldub [ %i1 ], %o1
4001c568: 40 00 17 d4 call 400224b8 <rtems_rfs_buffer_bdbuf_release>
4001c56c: c0 22 20 34 clr [ %o0 + 0x34 ]
4001c570: 10 bf ff c7 b 4001c48c <rtems_rfs_buffer_handle_release+0x54>
4001c574: b8 10 00 08 mov %o0, %i4
4001c578: 7f ff c4 ad call 4000d82c <_Chain_Append>
4001c57c: 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++;
4001c580: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
4001c584: 82 00 60 01 inc %g1
4001c588: 10 bf ff c1 b 4001c48c <rtems_rfs_buffer_handle_release+0x54>
4001c58c: 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))
4001c590: 90 10 20 00 clr %o0
4001c594: 7f ff de 44 call 40013ea4 <rtems_rfs_trace>
4001c598: 92 10 22 00 mov 0x200, %o1
4001c59c: 80 8a 20 ff btst 0xff, %o0
4001c5a0: 32 80 00 19 bne,a 4001c604 <rtems_rfs_buffer_handle_release+0x1cc><== NEVER TAKEN
4001c5a4: 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)
4001c5a8: c4 06 20 60 ld [ %i0 + 0x60 ], %g2
4001c5ac: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
4001c5b0: 80 a0 80 01 cmp %g2, %g1
4001c5b4: 08 80 00 0d bleu 4001c5e8 <rtems_rfs_buffer_handle_release+0x1b0>
4001c5b8: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4001c5bc: 7f ff c4 a7 call 4000d858 <_Chain_Get>
4001c5c0: 90 06 20 54 add %i0, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
4001c5c4: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
modified = false;
4001c5c8: 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--;
4001c5cc: 82 00 7f ff add %g1, -1, %g1
4001c5d0: 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;
4001c5d4: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001c5d8: 40 00 17 b8 call 400224b8 <rtems_rfs_buffer_bdbuf_release>
4001c5dc: 92 0a 60 01 and %o1, 1, %o1
4001c5e0: 10 bf ff cd b 4001c514 <rtems_rfs_buffer_handle_release+0xdc>
4001c5e4: b8 10 00 08 mov %o0, %i4
4001c5e8: 7f ff c4 9c call 4000d858 <_Chain_Get>
4001c5ec: 90 06 20 64 add %i0, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001c5f0: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
modified = true;
4001c5f4: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001c5f8: 82 00 7f ff add %g1, -1, %g1
4001c5fc: 10 bf ff f6 b 4001c5d4 <rtems_rfs_buffer_handle_release+0x19c>
4001c600: 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:"
4001c604: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 <== NOT EXECUTED
4001c608: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c60c: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
4001c610: 40 00 1e 5b call 40023f7c <printf> <== NOT EXECUTED
4001c614: 90 12 21 d8 or %o0, 0x1d8, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
4001c618: 10 bf ff e5 b 4001c5ac <rtems_rfs_buffer_handle_release+0x174><== NOT EXECUTED
4001c61c: c4 06 20 60 ld [ %i0 + 0x60 ], %g2 <== NOT EXECUTED
4001c620 <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)
{
4001c620: 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))
4001c624: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001c628: 80 a0 60 00 cmp %g1, 0
4001c62c: 02 80 00 17 be 4001c688 <rtems_rfs_buffer_handle_request+0x68>
4001c630: 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))
4001c634: 80 a6 a0 00 cmp %i2, 0
4001c638: 02 80 00 06 be 4001c650 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
4001c63c: 90 10 20 00 clr %o0
4001c640: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001c644: 80 a0 40 1a cmp %g1, %i2
4001c648: 02 80 00 40 be 4001c748 <rtems_rfs_buffer_handle_request+0x128>
4001c64c: 01 00 00 00 nop
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c650: 7f ff de 15 call 40013ea4 <rtems_rfs_trace>
4001c654: 92 10 21 00 mov 0x100, %o1 ! 100 <PROM_START+0x100>
4001c658: 80 8a 20 ff btst 0xff, %o0
4001c65c: 32 80 00 3d bne,a 4001c750 <rtems_rfs_buffer_handle_request+0x130><== NEVER TAKEN
4001c660: 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);
4001c664: 90 10 00 1d mov %i5, %o0
4001c668: 7f ff ff 74 call 4001c438 <rtems_rfs_buffer_handle_release>
4001c66c: 92 10 00 19 mov %i1, %o1
if (rc > 0)
4001c670: b0 92 20 00 orcc %o0, 0, %i0
4001c674: 24 80 00 04 ble,a 4001c684 <rtems_rfs_buffer_handle_request+0x64><== ALWAYS TAKEN
4001c678: 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;
}
4001c67c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c680: 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;
4001c684: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c688: 90 10 20 00 clr %o0
4001c68c: 7f ff de 06 call 40013ea4 <rtems_rfs_trace>
4001c690: 92 10 21 00 mov 0x100, %o1
4001c694: 80 8a 20 ff btst 0xff, %o0
4001c698: 32 80 00 5b bne,a 4001c804 <rtems_rfs_buffer_handle_request+0x1e4><== NEVER TAKEN
4001c69c: 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)
4001c6a0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4001c6a4: 80 a0 60 00 cmp %g1, 0
4001c6a8: 12 80 00 44 bne 4001c7b8 <rtems_rfs_buffer_handle_request+0x198>
4001c6ac: 90 07 60 44 add %i5, 0x44, %o0
4001c6b0: 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) &&
4001c6b4: c4 07 40 00 ld [ %i5 ], %g2
4001c6b8: 80 88 a0 02 btst 2, %g2
4001c6bc: 02 80 00 2a be 4001c764 <rtems_rfs_buffer_handle_request+0x144>
4001c6c0: 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))
4001c6c4: 02 80 00 65 be 4001c858 <rtems_rfs_buffer_handle_request+0x238><== ALWAYS TAKEN
4001c6c8: 90 10 00 1d mov %i5, %o0
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
4001c6cc: 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 );
4001c6d0: 92 10 00 01 mov %g1, %o1
4001c6d4: 84 00 a0 01 inc %g2
4001c6d8: 90 07 60 44 add %i5, 0x44, %o0
4001c6dc: 7f ff c4 54 call 4000d82c <_Chain_Append>
4001c6e0: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
4001c6e4: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
handle->buffer->user = (void*) ((intptr_t) block);
4001c6e8: 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++;
4001c6ec: 84 00 a0 01 inc %g2
4001c6f0: c4 27 60 50 st %g2, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
4001c6f4: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
4001c6f8: f4 26 60 04 st %i2, [ %i1 + 4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c6fc: 90 10 20 00 clr %o0
4001c700: 7f ff dd e9 call 40013ea4 <rtems_rfs_trace>
4001c704: 92 10 21 00 mov 0x100, %o1
4001c708: 80 8a 20 ff btst 0xff, %o0
4001c70c: 02 80 00 0f be 4001c748 <rtems_rfs_buffer_handle_request+0x128><== ALWAYS TAKEN
4001c710: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001c714: 02 80 00 41 be 4001c818 <rtems_rfs_buffer_handle_request+0x1f8><== NOT EXECUTED
4001c718: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
4001c71c: 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",
4001c720: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
4001c724: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
4001c728: 15 10 00 d8 sethi %hi(0x40036000), %o2 <== NOT EXECUTED
4001c72c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c730: 94 12 a2 d0 or %o2, 0x2d0, %o2 <== NOT EXECUTED
4001c734: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c738: 40 00 1e 11 call 40023f7c <printf> <== NOT EXECUTED
4001c73c: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
4001c740: 81 c7 e0 08 ret <== NOT EXECUTED
4001c744: 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;
4001c748: 81 c7 e0 08 ret
4001c74c: 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",
4001c750: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c754: 40 00 1e 0a call 40023f7c <printf> <== NOT EXECUTED
4001c758: 90 12 22 18 or %o0, 0x218, %o0 ! 40036e18 <CSWTCH.2+0x228><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
4001c75c: 10 bf ff c3 b 4001c668 <rtems_rfs_buffer_handle_request+0x48><== NOT EXECUTED
4001c760: 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) &&
4001c764: 32 bf ff db bne,a 4001c6d0 <rtems_rfs_buffer_handle_request+0xb0>
4001c768: 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)
4001c76c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001c770: 80 a0 60 00 cmp %g1, 0
4001c774: 12 80 00 5a bne 4001c8dc <rtems_rfs_buffer_handle_request+0x2bc>
4001c778: 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) &&
4001c77c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001c780: 80 a0 60 00 cmp %g1, 0
4001c784: 02 80 00 35 be 4001c858 <rtems_rfs_buffer_handle_request+0x238>
4001c788: 90 10 00 1d mov %i5, %o0
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
4001c78c: 90 07 60 64 add %i5, 0x64, %o0
4001c790: 92 07 60 70 add %i5, 0x70, %o1
4001c794: 7f ff fe e1 call 4001c318 <rtems_rfs_scan_chain>
4001c798: 94 10 00 1a mov %i2, %o2
4001c79c: 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))
4001c7a0: 80 a2 20 00 cmp %o0, 0
4001c7a4: 02 80 00 2c be 4001c854 <rtems_rfs_buffer_handle_request+0x234>
4001c7a8: 82 10 00 08 mov %o0, %g1
rtems_rfs_buffer_mark_dirty (handle);
4001c7ac: 84 10 20 01 mov 1, %g2
4001c7b0: 10 bf ff c7 b 4001c6cc <rtems_rfs_buffer_handle_request+0xac>
4001c7b4: 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,
4001c7b8: 92 07 60 50 add %i5, 0x50, %o1
4001c7bc: 7f ff fe d7 call 4001c318 <rtems_rfs_scan_chain>
4001c7c0: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
4001c7c4: 80 a2 20 00 cmp %o0, 0
4001c7c8: 02 80 00 1f be 4001c844 <rtems_rfs_buffer_handle_request+0x224>
4001c7cc: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c7d0: 90 10 20 00 clr %o0
4001c7d4: 7f ff dd b4 call 40013ea4 <rtems_rfs_trace>
4001c7d8: 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) &&
4001c7dc: 80 8a 20 ff btst 0xff, %o0
4001c7e0: 02 bf ff b5 be 4001c6b4 <rtems_rfs_buffer_handle_request+0x94><== ALWAYS TAKEN
4001c7e4: 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",
4001c7e8: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
4001c7ec: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c7f0: 92 02 60 01 inc %o1 <== NOT EXECUTED
4001c7f4: 40 00 1d e2 call 40023f7c <printf> <== NOT EXECUTED
4001c7f8: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
4001c7fc: 10 bf ff ae b 4001c6b4 <rtems_rfs_buffer_handle_request+0x94><== NOT EXECUTED
4001c800: 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);
4001c804: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c808: 40 00 1d dd call 40023f7c <printf> <== NOT EXECUTED
4001c80c: 90 12 22 50 or %o0, 0x250, %o0 ! 40036e50 <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)
4001c810: 10 bf ff a5 b 4001c6a4 <rtems_rfs_buffer_handle_request+0x84><== NOT EXECUTED
4001c814: 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;
4001c818: 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",
4001c81c: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
4001c820: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
4001c824: 15 10 00 db sethi %hi(0x40036c00), %o2 <== NOT EXECUTED
4001c828: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c82c: 94 12 a2 10 or %o2, 0x210, %o2 <== NOT EXECUTED
4001c830: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c834: 40 00 1d d2 call 40023f7c <printf> <== NOT EXECUTED
4001c838: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
4001c83c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c840: 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) &&
4001c844: c2 07 40 00 ld [ %i5 ], %g1
4001c848: 80 88 60 02 btst 2, %g1
4001c84c: 22 bf ff c9 be,a 4001c770 <rtems_rfs_buffer_handle_request+0x150>
4001c850: 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);
4001c854: 90 10 00 1d mov %i5, %o0
4001c858: 92 10 00 1a mov %i2, %o1
4001c85c: 94 10 00 1b mov %i3, %o2
4001c860: 40 00 17 02 call 40022468 <rtems_rfs_buffer_bdbuf_request>
4001c864: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
4001c868: b0 92 20 00 orcc %o0, 0, %i0
4001c86c: 04 80 00 16 ble 4001c8c4 <rtems_rfs_buffer_handle_request+0x2a4><== ALWAYS TAKEN
4001c870: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001c874: 7f ff dd 8c call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001c878: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
4001c87c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c880: 02 bf ff 7f be 4001c67c <rtems_rfs_buffer_handle_request+0x5c><== NOT EXECUTED
4001c884: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001c888: 02 80 00 13 be 4001c8d4 <rtems_rfs_buffer_handle_request+0x2b4><== NOT EXECUTED
4001c88c: 3b 10 00 db sethi %hi(0x40036c00), %i5 <== NOT EXECUTED
4001c890: 3b 10 00 d8 sethi %hi(0x40036000), %i5 <== NOT EXECUTED
4001c894: ba 17 62 d0 or %i5, 0x2d0, %i5 ! 400362d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001c898: 40 00 22 03 call 400250a4 <strerror> <== NOT EXECUTED
4001c89c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c8a0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c8a4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001c8a8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001c8ac: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c8b0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001c8b4: 40 00 1d b2 call 40023f7c <printf> <== NOT EXECUTED
4001c8b8: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
4001c8bc: 81 c7 e0 08 ret <== NOT EXECUTED
4001c8c0: 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));
4001c8c4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001c8c8: c0 20 60 04 clr [ %g1 + 4 ]
4001c8cc: 10 bf ff 80 b 4001c6cc <rtems_rfs_buffer_handle_request+0xac>
4001c8d0: 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",
4001c8d4: 10 bf ff f1 b 4001c898 <rtems_rfs_buffer_handle_request+0x278><== NOT EXECUTED
4001c8d8: ba 17 62 10 or %i5, 0x210, %i5 <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
4001c8dc: 92 07 60 60 add %i5, 0x60, %o1
4001c8e0: 7f ff fe 8e call 4001c318 <rtems_rfs_scan_chain>
4001c8e4: 94 10 00 1a mov %i2, %o2
4001c8e8: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001c8ec: 80 a2 20 00 cmp %o0, 0
4001c8f0: 12 bf ff 77 bne 4001c6cc <rtems_rfs_buffer_handle_request+0xac>
4001c8f4: 82 10 00 08 mov %o0, %g1
4001c8f8: 10 bf ff a2 b 4001c780 <rtems_rfs_buffer_handle_request+0x160>
4001c8fc: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001c900 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
4001c900: 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))
4001c904: 90 10 20 00 clr %o0
4001c908: 92 10 20 20 mov 0x20, %o1
4001c90c: 7f ff dd 66 call 40013ea4 <rtems_rfs_trace>
4001c910: ba 10 00 18 mov %i0, %i5
4001c914: 80 8a 20 ff btst 0xff, %o0
4001c918: 12 80 00 1b bne 4001c984 <rtems_rfs_buffer_open+0x84> <== NEVER TAKEN
4001c91c: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
fs->device = open (name, O_RDWR);
4001c920: 90 10 00 1d mov %i5, %o0
4001c924: 7f ff b1 4e call 40008e5c <open>
4001c928: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
4001c92c: 80 a2 20 00 cmp %o0, 0
4001c930: 06 80 00 1e bl 4001c9a8 <rtems_rfs_buffer_open+0xa8> <== NEVER TAKEN
4001c934: 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)
4001c938: 7f ff ad ae call 40007ff0 <fstat>
4001c93c: 92 07 bf b8 add %fp, -72, %o1
4001c940: 80 a2 20 00 cmp %o0, 0
4001c944: 06 80 00 3b bl 4001ca30 <rtems_rfs_buffer_open+0x130> <== NEVER TAKEN
4001c948: 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))
4001c94c: 03 00 00 3c sethi %hi(0xf000), %g1
4001c950: 84 08 80 01 and %g2, %g1, %g2
4001c954: 03 00 00 18 sethi %hi(0x6000), %g1
4001c958: 80 a0 80 01 cmp %g2, %g1
4001c95c: 22 80 00 1e be,a 4001c9d4 <rtems_rfs_buffer_open+0xd4> <== ALWAYS TAKEN
4001c960: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c964: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c968: 7f ff dd 4f call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001c96c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001c970: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c974: 32 80 00 29 bne,a 4001ca18 <rtems_rfs_buffer_open+0x118> <== NOT EXECUTED
4001c978: 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;
4001c97c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c980: 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);
4001c984: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c988: 40 00 1d 7d call 40023f7c <printf> <== NOT EXECUTED
4001c98c: 90 12 23 28 or %o0, 0x328, %o0 ! 40036f28 <CSWTCH.2+0x338><== NOT EXECUTED
fs->device = open (name, O_RDWR);
4001c990: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001c994: 7f ff b1 32 call 40008e5c <open> <== NOT EXECUTED
4001c998: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
if (fs->device < 0)
4001c99c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001c9a0: 16 bf ff e6 bge 4001c938 <rtems_rfs_buffer_open+0x38> <== NOT EXECUTED
4001c9a4: d0 26 60 0c st %o0, [ %i1 + 0xc ] <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c9a8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c9ac: 7f ff dd 3e call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001c9b0: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001c9b4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c9b8: 02 bf ff f1 be 4001c97c <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
4001c9bc: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
4001c9c0: 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");
4001c9c4: 40 00 1e 06 call 400241dc <puts> <== NOT EXECUTED
4001c9c8: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
4001c9cc: 81 c7 e0 08 ret <== NOT EXECUTED
4001c9d0: 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);
4001c9d4: 94 06 60 10 add %i1, 0x10, %o2
4001c9d8: 13 10 01 10 sethi %hi(0x40044000), %o1
4001c9dc: 7f ff ad db call 40008148 <ioctl>
4001c9e0: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <flashdisk_data+0xa961>
/*
* 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)
4001c9e4: 80 a2 20 00 cmp %o0, 0
4001c9e8: 02 80 00 23 be 4001ca74 <rtems_rfs_buffer_open+0x174> <== ALWAYS TAKEN
4001c9ec: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001c9f0: 7f ff dd 2d call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001c9f4: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001c9f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c9fc: 02 bf ff e0 be 4001c97c <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
4001ca00: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return ENXIO;
4001ca04: 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");
4001ca08: 40 00 1d f5 call 400241dc <puts> <== NOT EXECUTED
4001ca0c: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
4001ca10: 81 c7 e0 08 ret <== NOT EXECUTED
4001ca14: 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);
4001ca18: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001ca1c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001ca20: 40 00 1d 57 call 40023f7c <printf> <== NOT EXECUTED
4001ca24: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 40036fb0 <CSWTCH.2+0x3c0><== NOT EXECUTED
4001ca28: 81 c7 e0 08 ret <== NOT EXECUTED
4001ca2c: 81 e8 00 00 restore <== NOT EXECUTED
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001ca30: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ca34: 7f ff dd 1c call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001ca38: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001ca3c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ca40: 02 bf ff cf be 4001c97c <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
4001ca44: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
4001ca48: 40 00 17 bc call 40022938 <__errno> <== NOT EXECUTED
4001ca4c: 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",
4001ca50: 40 00 21 95 call 400250a4 <strerror> <== NOT EXECUTED
4001ca54: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4001ca58: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001ca5c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ca60: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001ca64: 40 00 1d 46 call 40023f7c <printf> <== NOT EXECUTED
4001ca68: 90 12 23 80 or %o0, 0x380, %o0 ! 40036f80 <CSWTCH.2+0x390><== NOT EXECUTED
4001ca6c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ca70: 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))
4001ca74: 92 10 20 20 mov 0x20, %o1
4001ca78: 7f ff dd 0b call 40013ea4 <rtems_rfs_trace>
4001ca7c: b0 10 20 00 clr %i0
4001ca80: 80 8a 20 ff btst 0xff, %o0
4001ca84: 32 80 00 04 bne,a 4001ca94 <rtems_rfs_buffer_open+0x194> <== NEVER TAKEN
4001ca88: 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;
}
4001ca8c: 81 c7 e0 08 ret
4001ca90: 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",
4001ca94: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001ca98: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4001ca9c: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
4001caa0: 40 00 1d 37 call 40023f7c <printf> <== NOT EXECUTED
4001caa4: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
4001caa8: 81 c7 e0 08 ret <== NOT EXECUTED
4001caac: 81 e8 00 00 restore <== NOT EXECUTED
4001cbcc <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001cbcc: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001cbd0: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001cbd4: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001cbd8: 7f ff dc b3 call 40013ea4 <rtems_rfs_trace>
4001cbdc: 92 10 24 00 mov 0x400, %o1
4001cbe0: 80 8a 20 ff btst 0xff, %o0
4001cbe4: 12 80 00 21 bne 4001cc68 <rtems_rfs_buffer_setblksize+0x9c><== NEVER TAKEN
4001cbe8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
4001cbec: 7f ff ff d7 call 4001cb48 <rtems_rfs_buffers_release>
4001cbf0: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001cbf4: ba 92 20 00 orcc %o0, 0, %i5
4001cbf8: 04 80 00 07 ble 4001cc14 <rtems_rfs_buffer_setblksize+0x48><== ALWAYS TAKEN
4001cbfc: 90 10 20 00 clr %o0
4001cc00: 7f ff dc a9 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001cc04: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001cc08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cc0c: 12 80 00 20 bne 4001cc8c <rtems_rfs_buffer_setblksize+0xc0><== NOT EXECUTED
4001cc10: 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);
4001cc14: 7f ff ff a7 call 4001cab0 <rtems_rfs_buffer_sync>
4001cc18: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001cc1c: ba 92 20 00 orcc %o0, 0, %i5
4001cc20: 04 80 00 07 ble 4001cc3c <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
4001cc24: 90 10 20 00 clr %o0
4001cc28: 7f ff dc 9f call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001cc2c: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001cc30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cc34: 12 80 00 1e bne 4001ccac <rtems_rfs_buffer_setblksize+0xe0><== NOT EXECUTED
4001cc38: 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);
4001cc3c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001cc40: 13 20 01 10 sethi %hi(0x80044000), %o1
4001cc44: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4001cc48: 92 12 62 04 or %o1, 0x204, %o1
4001cc4c: 9f c0 40 00 call %g1
4001cc50: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
4001cc54: b0 92 20 00 orcc %o0, 0, %i0
4001cc58: 06 80 00 08 bl 4001cc78 <rtems_rfs_buffer_setblksize+0xac><== NEVER TAKEN
4001cc5c: 01 00 00 00 nop
rc = errno;
#endif
return rc;
}
4001cc60: 81 c7 e0 08 ret
4001cc64: 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);
4001cc68: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001cc6c: 40 00 1c c4 call 40023f7c <printf> <== NOT EXECUTED
4001cc70: 90 12 20 e8 or %o0, 0xe8, %o0 ! 400370e8 <CSWTCH.2+0x4f8> <== NOT EXECUTED
4001cc74: 30 bf ff de b,a 4001cbec <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;
4001cc78: 40 00 17 30 call 40022938 <__errno> <== NOT EXECUTED
4001cc7c: 01 00 00 00 nop <== NOT EXECUTED
4001cc80: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
4001cc84: 81 c7 e0 08 ret <== NOT EXECUTED
4001cc88: 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",
4001cc8c: 40 00 21 06 call 400250a4 <strerror> <== NOT EXECUTED
4001cc90: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001cc94: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001cc98: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001cc9c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001cca0: 40 00 1c b7 call 40023f7c <printf> <== NOT EXECUTED
4001cca4: 90 12 21 18 or %o0, 0x118, %o0 ! 40037118 <CSWTCH.2+0x528><== NOT EXECUTED
4001cca8: 30 bf ff db b,a 4001cc14 <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",
4001ccac: 40 00 20 fe call 400250a4 <strerror> <== NOT EXECUTED
4001ccb0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ccb4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001ccb8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ccbc: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001ccc0: 40 00 1c af call 40023f7c <printf> <== NOT EXECUTED
4001ccc4: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <CSWTCH.2+0x568><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001ccc8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
4001cccc: 13 20 01 10 sethi %hi(0x80044000), %o1 <== NOT EXECUTED
4001ccd0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED
4001ccd4: 92 12 62 04 or %o1, 0x204, %o1 <== NOT EXECUTED
4001ccd8: 9f c0 40 00 call %g1 <== NOT EXECUTED
4001ccdc: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
if (rc < 0)
4001cce0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001cce4: 16 bf ff e8 bge 4001cc84 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
4001cce8: 01 00 00 00 nop <== NOT EXECUTED
4001ccec: 30 bf ff e3 b,a 4001cc78 <rtems_rfs_buffer_setblksize+0xac><== NOT EXECUTED
4001cab0 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
4001cab0: 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))
4001cab4: 90 10 20 00 clr %o0
4001cab8: 92 10 20 20 mov 0x20, %o1
4001cabc: 7f ff dc fa call 40013ea4 <rtems_rfs_trace>
4001cac0: ba 10 00 18 mov %i0, %i5
4001cac4: 80 8a 20 ff btst 0xff, %o0
4001cac8: 12 80 00 1c bne 4001cb38 <rtems_rfs_buffer_sync+0x88> <== NEVER TAKEN
4001cacc: 11 10 00 dc sethi %hi(0x40037000), %o0
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
4001cad0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
4001cad4: 7f ff e7 26 call 4001676c <rtems_bdbuf_syncdev>
4001cad8: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001cadc: b8 92 20 00 orcc %o0, 0, %i4
4001cae0: 12 80 00 06 bne 4001caf8 <rtems_rfs_buffer_sync+0x48> <== NEVER TAKEN
4001cae4: 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);
4001cae8: 7f ff 9e 14 call 40004338 <rtems_disk_release>
4001caec: 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;
}
4001caf0: 81 c7 e0 08 ret
4001caf4: 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))
4001caf8: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
4001cafc: 7f ff dc ea call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001cb00: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001cb04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cb08: 02 bf ff f8 be 4001cae8 <rtems_rfs_buffer_sync+0x38> <== NOT EXECUTED
4001cb0c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
4001cb10: 7f ff eb 40 call 40017810 <rtems_status_text> <== NOT EXECUTED
4001cb14: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001cb18: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001cb1c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001cb20: 40 00 1d 17 call 40023f7c <printf> <== NOT EXECUTED
4001cb24: 90 12 20 68 or %o0, 0x68, %o0 ! 40037068 <CSWTCH.2+0x478> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
4001cb28: 7f ff 9e 04 call 40004338 <rtems_disk_release> <== NOT EXECUTED
4001cb2c: 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;
}
4001cb30: 81 c7 e0 08 ret <== NOT EXECUTED
4001cb34: 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");
4001cb38: 40 00 1d a9 call 400241dc <puts> <== NOT EXECUTED
4001cb3c: 90 12 20 48 or %o0, 0x48, %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));
4001cb40: 10 bf ff e5 b 4001cad4 <rtems_rfs_buffer_sync+0x24> <== NOT EXECUTED
4001cb44: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4001cb48 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
4001cb48: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4001cb4c: 90 10 20 00 clr %o0
4001cb50: 7f ff dc d5 call 40013ea4 <rtems_rfs_trace>
4001cb54: 92 10 20 40 mov 0x40, %o1
4001cb58: 80 8a 20 ff btst 0xff, %o0
4001cb5c: 32 80 00 15 bne,a 4001cbb0 <rtems_rfs_buffers_release+0x68><== NEVER TAKEN
4001cb60: 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,
4001cb64: 92 06 20 60 add %i0, 0x60, %o1
4001cb68: 94 10 20 00 clr %o2
4001cb6c: 7f ff fd c4 call 4001c27c <rtems_rfs_release_chain>
4001cb70: 90 06 20 54 add %i0, 0x54, %o0
4001cb74: 82 38 00 08 xnor %g0, %o0, %g1
4001cb78: 83 38 60 1f sra %g1, 0x1f, %g1
4001cb7c: 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,
4001cb80: 92 06 20 70 add %i0, 0x70, %o1
4001cb84: ba 0f 40 01 and %i5, %g1, %i5
4001cb88: 90 06 20 64 add %i0, 0x64, %o0
4001cb8c: 7f ff fd bc call 4001c27c <rtems_rfs_release_chain>
4001cb90: 94 10 20 01 mov 1, %o2
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
4001cb94: 80 a7 60 00 cmp %i5, 0
4001cb98: 12 80 00 04 bne 4001cba8 <rtems_rfs_buffers_release+0x60> <== NEVER TAKEN
4001cb9c: 80 a2 20 00 cmp %o0, 0
4001cba0: 34 80 00 02 bg,a 4001cba8 <rtems_rfs_buffers_release+0x60><== NEVER TAKEN
4001cba4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rrc = rc;
return rrc;
}
4001cba8: 81 c7 e0 08 ret
4001cbac: 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 " "
4001cbb0: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
4001cbb4: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
4001cbb8: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001cbbc: 40 00 1c f0 call 40023f7c <printf> <== NOT EXECUTED
4001cbc0: 90 12 20 98 or %o0, 0x98, %o0 ! 40037098 <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,
4001cbc4: 10 bf ff e9 b 4001cb68 <rtems_rfs_buffers_release+0x20> <== NOT EXECUTED
4001cbc8: 92 06 20 60 add %i0, 0x60, %o1 <== NOT EXECUTED
4001d324 <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)
{
4001d324: 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))
4001d328: 90 10 20 00 clr %o0
4001d32c: 7f ff da de call 40013ea4 <rtems_rfs_trace>
4001d330: 13 08 00 00 sethi %hi(0x20000000), %o1
4001d334: 80 8a 20 ff btst 0xff, %o0
4001d338: 32 80 00 7c bne,a 4001d528 <rtems_rfs_dir_add_entry+0x204><== NEVER TAKEN
4001d33c: 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);
4001d340: 90 10 00 18 mov %i0, %o0
4001d344: 92 10 00 19 mov %i1, %o1
4001d348: 7f ff f8 b2 call 4001b610 <rtems_rfs_block_map_open>
4001d34c: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001d350: ba 92 20 00 orcc %o0, 0, %i5
4001d354: 04 80 00 04 ble 4001d364 <rtems_rfs_dir_add_entry+0x40> <== ALWAYS TAKEN
4001d358: 29 00 00 3f sethi %hi(0xfc00), %l4
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001d35c: 81 c7 e0 08 ret
4001d360: 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;
4001d364: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001d368: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001d36c: 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;
4001d370: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
4001d374: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
4001d378: 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)
4001d37c: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001d380: 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);
4001d384: 90 10 00 18 mov %i0, %o0
4001d388: 92 07 bf b0 add %fp, -80, %o1
4001d38c: 94 07 bf 98 add %fp, -104, %o2
4001d390: 7f ff f9 75 call 4001b964 <rtems_rfs_block_map_find>
4001d394: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001d398: ba 92 20 00 orcc %o0, 0, %i5
4001d39c: 04 80 00 ae ble 4001d654 <rtems_rfs_dir_add_entry+0x330>
4001d3a0: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
4001d3a4: 12 80 00 c7 bne 4001d6c0 <rtems_rfs_dir_add_entry+0x39c> <== NEVER TAKEN
4001d3a8: 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);
4001d3ac: 92 07 bf b0 add %fp, -80, %o1
4001d3b0: 94 10 20 01 mov 1, %o2
4001d3b4: 7f ff f9 f0 call 4001bb74 <rtems_rfs_block_map_grow>
4001d3b8: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001d3bc: ba 92 20 00 orcc %o0, 0, %i5
4001d3c0: 14 80 00 d1 bg 4001d704 <rtems_rfs_dir_add_entry+0x3e0> <== NEVER TAKEN
4001d3c4: a0 10 20 00 clr %l0
}
read = false;
}
bpos.bno++;
4001d3c8: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001d3cc: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
4001d3d0: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001d3d4: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
4001d3d8: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001d3dc: 90 10 00 18 mov %i0, %o0
4001d3e0: 92 07 bf a4 add %fp, -92, %o1
4001d3e4: 7f ff fc 8f call 4001c620 <rtems_rfs_buffer_handle_request>
4001d3e8: 96 10 00 10 mov %l0, %o3
if (rc > 0)
4001d3ec: ba 92 20 00 orcc %o0, 0, %i5
4001d3f0: 14 80 00 9b bg 4001d65c <rtems_rfs_dir_add_entry+0x338> <== NEVER TAKEN
4001d3f4: c2 07 bf ac ld [ %fp + -84 ], %g1
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
4001d3f8: 80 a4 20 00 cmp %l0, 0
4001d3fc: 02 80 00 5e be 4001d574 <rtems_rfs_dir_add_entry+0x250>
4001d400: 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))
4001d404: da 06 20 08 ld [ %i0 + 8 ], %o5
4001d408: 9e 83 7f f6 addcc %o5, -10, %o7
4001d40c: 02 bf ff df be 4001d388 <rtems_rfs_dir_add_entry+0x64> <== NEVER TAKEN
4001d410: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001d414: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
4001d418: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
4001d41c: e4 0f 40 00 ldub [ %i5 ], %l2
4001d420: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
4001d424: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
4001d428: 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);
4001d42c: a1 2c 20 08 sll %l0, 8, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001d430: 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);
4001d434: a0 14 00 04 or %l0, %g4, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001d438: 87 28 e0 08 sll %g3, 8, %g3
4001d43c: 83 28 60 10 sll %g1, 0x10, %g1
4001d440: a4 14 80 03 or %l2, %g3, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d444: 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);
4001d448: a4 14 80 02 or %l2, %g2, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d44c: 02 80 00 58 be 4001d5ac <rtems_rfs_dir_add_entry+0x288>
4001d450: a4 14 80 01 or %l2, %g1, %l2
4001d454: 10 80 00 20 b 4001d4d4 <rtems_rfs_dir_add_entry+0x1b0>
4001d458: a2 10 20 00 clr %l1
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d45c: 80 a4 00 01 cmp %l0, %g1
4001d460: 1a 80 00 20 bcc 4001d4e0 <rtems_rfs_dir_add_entry+0x1bc> <== NEVER TAKEN
4001d464: ba 07 40 10 add %i5, %l0, %i5
4001d468: 80 a4 a0 00 cmp %l2, 0
4001d46c: 02 80 00 1e be 4001d4e4 <rtems_rfs_dir_add_entry+0x1c0> <== NEVER TAKEN
4001d470: 90 10 20 00 clr %o0
4001d474: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001d478: 80 a0 40 12 cmp %g1, %l2
4001d47c: 0a 80 00 1a bcs 4001d4e4 <rtems_rfs_dir_add_entry+0x1c0> <== NEVER TAKEN
4001d480: 01 00 00 00 nop
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
4001d484: 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))
4001d488: 80 a4 40 0f cmp %l1, %o7
4001d48c: 1a bf ff be bcc 4001d384 <rtems_rfs_dir_add_entry+0x60> <== NEVER TAKEN
4001d490: 98 10 00 11 mov %l1, %o4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001d494: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
4001d498: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
4001d49c: e4 0f 40 00 ldub [ %i5 ], %l2
4001d4a0: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
4001d4a4: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
4001d4a8: 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);
4001d4ac: a1 2c 20 08 sll %l0, 8, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001d4b0: 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);
4001d4b4: a0 14 00 04 or %l0, %g4, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001d4b8: 87 28 e0 10 sll %g3, 0x10, %g3
4001d4bc: 83 28 60 08 sll %g1, 8, %g1
4001d4c0: a4 14 80 03 or %l2, %g3, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d4c4: 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);
4001d4c8: a4 14 80 02 or %l2, %g2, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d4cc: 02 80 00 39 be 4001d5b0 <rtems_rfs_dir_add_entry+0x28c>
4001d4d0: a4 14 80 01 or %l2, %g1, %l2
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001d4d4: 80 a4 20 0a cmp %l0, 0xa
4001d4d8: 34 bf ff e1 bg,a 4001d45c <rtems_rfs_dir_add_entry+0x138><== ALWAYS TAKEN
4001d4dc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001d4e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d4e4: 7f ff da 70 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d4e8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001d4ec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d4f0: 32 80 00 27 bne,a 4001d58c <rtems_rfs_dir_add_entry+0x268><== NOT EXECUTED
4001d4f4: 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);
4001d4f8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001d4fc: 7f ff fb cf call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d500: 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);
4001d504: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001d508: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
4001d50c: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
4001d510: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
4001d514: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001d518: 7f ff f8 9f call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001d51c: 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;
}
4001d520: 81 c7 e0 08 ret <== NOT EXECUTED
4001d524: 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=",
4001d528: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d52c: 40 00 1a 94 call 40023f7c <printf> <== NOT EXECUTED
4001d530: 90 12 21 08 or %o0, 0x108, %o0 ! 40037508 <CSWTCH.2+0x918><== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
4001d534: ba 10 20 00 clr %i5 <== NOT EXECUTED
4001d538: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
4001d53c: 02 80 00 08 be 4001d55c <rtems_rfs_dir_add_entry+0x238> <== NOT EXECUTED
4001d540: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("%c", name[c]);
4001d544: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 <== NOT EXECUTED
4001d548: 40 00 1a f7 call 40024124 <putchar> <== NOT EXECUTED
4001d54c: 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++)
4001d550: 80 a7 40 1b cmp %i5, %i3 <== NOT EXECUTED
4001d554: 12 bf ff fc bne 4001d544 <rtems_rfs_dir_add_entry+0x220> <== NOT EXECUTED
4001d558: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
4001d55c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001d560: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d564: 40 00 1a 86 call 40023f7c <printf> <== NOT EXECUTED
4001d568: 90 12 21 38 or %o0, 0x138, %o0 ! 40037538 <CSWTCH.2+0x948><== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d56c: 10 bf ff 76 b 4001d344 <rtems_rfs_dir_add_entry+0x20> <== NOT EXECUTED
4001d570: 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));
4001d574: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001d578: 90 10 00 1d mov %i5, %o0
4001d57c: 40 00 1a 02 call 40023d84 <memset>
4001d580: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d584: 10 bf ff a1 b 4001d408 <rtems_rfs_dir_add_entry+0xe4>
4001d588: 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: "
4001d58c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001d590: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d594: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001d598: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
4001d59c: 40 00 1a 78 call 40023f7c <printf> <== NOT EXECUTED
4001d5a0: 90 12 22 20 or %o0, 0x220, %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);
4001d5a4: 10 bf ff d6 b 4001d4fc <rtems_rfs_dir_add_entry+0x1d8> <== NOT EXECUTED
4001d5a8: 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))
4001d5ac: 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))
4001d5b0: 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) <
4001d5b4: 80 a4 c0 0d cmp %l3, %o5
4001d5b8: 3a bf ff 74 bcc,a 4001d388 <rtems_rfs_dir_add_entry+0x64><== NEVER TAKEN
4001d5bc: 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);
4001d5c0: 92 10 00 1b mov %i3, %o1
4001d5c4: 40 00 13 ed call 40022578 <rtems_rfs_dir_hash>
4001d5c8: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
4001d5cc: 83 32 20 08 srl %o0, 8, %g1
4001d5d0: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001d5d4: 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);
4001d5d8: 85 32 20 10 srl %o0, 0x10, %g2
rtems_rfs_dir_set_entry_ino (entry, ino);
4001d5dc: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
4001d5e0: 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);
4001d5e4: 87 32 20 18 srl %o0, 0x18, %g3
4001d5e8: c4 2f 60 05 stb %g2, [ %i5 + 5 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001d5ec: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
4001d5f0: 85 37 20 18 srl %i4, 0x18, %g2
rtems_rfs_dir_set_entry_length (entry,
4001d5f4: 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);
4001d5f8: c6 2f 60 04 stb %g3, [ %i5 + 4 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001d5fc: 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);
4001d600: 94 10 00 1b mov %i3, %o2
4001d604: 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);
4001d608: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001d60c: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
4001d610: e6 2f 60 09 stb %l3, [ %i5 + 9 ]
4001d614: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001d618: 40 00 19 4c call 40023b48 <memcpy>
4001d61c: 90 07 60 0a add %i5, 0xa, %o0
rtems_rfs_buffer_mark_dirty (&buffer);
4001d620: 82 10 20 01 mov 1, %g1
4001d624: 92 07 bf a4 add %fp, -92, %o1
4001d628: 90 10 00 18 mov %i0, %o0
4001d62c: 7f ff fb 83 call 4001c438 <rtems_rfs_buffer_handle_release>
4001d630: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001d634: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001d638: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001d63c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001d640: c0 27 bf ac clr [ %fp + -84 ]
4001d644: 92 07 bf b0 add %fp, -80, %o1
4001d648: 7f ff f8 53 call 4001b794 <rtems_rfs_block_map_close>
4001d64c: ba 10 20 00 clr %i5
4001d650: 30 bf ff 43 b,a 4001d35c <rtems_rfs_dir_add_entry+0x38>
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
4001d654: 10 bf ff 5d b 4001d3c8 <rtems_rfs_dir_add_entry+0xa4>
4001d658: 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))
4001d65c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d660: 7f ff da 11 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d664: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001d668: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d66c: 22 80 00 0c be,a 4001d69c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001d670: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001d674: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001d678: 40 00 1e 8b call 400250a4 <strerror> <== NOT EXECUTED
4001d67c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d680: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001d684: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d688: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001d68c: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d690: 40 00 1a 3b call 40023f7c <printf> <== NOT EXECUTED
4001d694: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400375d8 <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);
4001d698: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001d69c: 7f ff fb 67 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d6a0: 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);
4001d6a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001d6a8: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
4001d6ac: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
4001d6b0: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
4001d6b4: 7f ff f8 38 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001d6b8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001d6bc: 30 bf ff 28 b,a 4001d35c <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))
4001d6c0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d6c4: 7f ff d9 f8 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d6c8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001d6cc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d6d0: 22 bf ff f3 be,a 4001d69c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001d6d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001d6d8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001d6dc: 40 00 1e 72 call 400250a4 <strerror> <== NOT EXECUTED
4001d6e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d6e4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001d6e8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d6ec: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001d6f0: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d6f4: 40 00 1a 22 call 40023f7c <printf> <== NOT EXECUTED
4001d6f8: 90 12 21 48 or %o0, 0x148, %o0 ! 40037548 <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);
4001d6fc: 10 bf ff e8 b 4001d69c <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
4001d700: 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))
4001d704: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d708: 7f ff d9 e7 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d70c: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001d710: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d714: 22 bf ff e2 be,a 4001d69c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001d718: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001d71c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001d720: 40 00 1e 61 call 400250a4 <strerror> <== NOT EXECUTED
4001d724: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d728: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001d72c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d730: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001d734: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d738: 40 00 1a 11 call 40023f7c <printf> <== NOT EXECUTED
4001d73c: 90 12 21 90 or %o0, 0x190, %o0 ! 40037590 <CSWTCH.2+0x9a0><== NOT EXECUTED
4001d740: 10 bf ff d7 b 4001d69c <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
4001d744: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001d748 <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)
{
4001d748: 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))
4001d74c: 90 10 20 00 clr %o0
4001d750: 13 10 00 00 sethi %hi(0x40000000), %o1
4001d754: 7f ff d9 d4 call 40013ea4 <rtems_rfs_trace>
4001d758: a2 10 00 18 mov %i0, %l1
4001d75c: 80 8a 20 ff btst 0xff, %o0
4001d760: 12 80 00 0a bne 4001d788 <rtems_rfs_dir_del_entry+0x40> <== NEVER TAKEN
4001d764: 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);
4001d768: 90 10 00 11 mov %l1, %o0
4001d76c: 7f ff f7 a9 call 4001b610 <rtems_rfs_block_map_open>
4001d770: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001d774: b0 92 20 00 orcc %o0, 0, %i0
4001d778: 04 80 00 11 ble 4001d7bc <rtems_rfs_dir_del_entry+0x74> <== ALWAYS TAKEN
4001d77c: 90 10 00 11 mov %l1, %o0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001d780: 81 c7 e0 08 ret <== NOT EXECUTED
4001d784: 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",
4001d788: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d78c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001d790: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001d794: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d798: 40 00 19 f9 call 40023f7c <printf> <== NOT EXECUTED
4001d79c: 90 12 22 68 or %o0, 0x268, %o0 ! 40037668 <CSWTCH.2+0xa78><== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001d7a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001d7a4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001d7a8: 7f ff f7 9a call 4001b610 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001d7ac: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
4001d7b0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001d7b4: 14 bf ff f3 bg 4001d780 <rtems_rfs_dir_del_entry+0x38> <== NOT EXECUTED
4001d7b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001d7bc: 92 07 bf b0 add %fp, -80, %o1
4001d7c0: 94 10 20 00 clr %o2
4001d7c4: 96 10 00 1b mov %i3, %o3
4001d7c8: 7f ff f8 c1 call 4001bacc <rtems_rfs_block_map_seek>
4001d7cc: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001d7d0: b0 92 20 00 orcc %o0, 0, %i0
4001d7d4: 04 80 00 09 ble 4001d7f8 <rtems_rfs_dir_del_entry+0xb0> <== ALWAYS TAKEN
4001d7d8: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
4001d7dc: 22 80 00 02 be,a 4001d7e4 <rtems_rfs_dir_del_entry+0x9c> <== NOT EXECUTED
4001d7e0: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
4001d7e4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001d7e8: 7f ff f7 eb call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001d7ec: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001d7f0: 81 c7 e0 08 ret <== NOT EXECUTED
4001d7f4: 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)
4001d7f8: 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)
4001d7fc: 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;
4001d800: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001d804: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001d808: 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)
4001d80c: 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)
4001d810: 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);
4001d814: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001d818: 90 10 00 11 mov %l1, %o0
4001d81c: 92 07 bf a4 add %fp, -92, %o1
4001d820: 7f ff fb 80 call 4001c620 <rtems_rfs_buffer_handle_request>
4001d824: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001d828: b0 92 20 00 orcc %o0, 0, %i0
4001d82c: 14 80 00 cc bg 4001db5c <rtems_rfs_dir_del_entry+0x414> <== NEVER TAKEN
4001d830: 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)
4001d834: 02 80 00 63 be 4001d9c0 <rtems_rfs_dir_del_entry+0x278> <== ALWAYS TAKEN
4001d838: ea 04 60 08 ld [ %l1 + 8 ], %l5
4001d83c: 90 10 20 00 clr %o0 <== NOT EXECUTED
eoffset = 0;
4001d840: a4 10 20 00 clr %l2 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001d844: c2 07 bf ac ld [ %fp + -84 ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d848: 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;
4001d84c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d850: 80 a3 c0 08 cmp %o7, %o0
4001d854: 08 80 00 33 bleu 4001d920 <rtems_rfs_dir_del_entry+0x1d8> <== NEVER TAKEN
4001d858: ba 00 40 08 add %g1, %o0, %i5
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001d85c: f8 0f 60 08 ldub [ %i5 + 8 ], %i4
4001d860: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
4001d864: e0 0f 60 01 ldub [ %i5 + 1 ], %l0
4001d868: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
4001d86c: 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);
4001d870: b9 2f 20 08 sll %i4, 8, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001d874: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
4001d878: 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);
4001d87c: b8 17 00 04 or %i4, %g4, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001d880: 87 28 e0 08 sll %g3, 8, %g3
4001d884: 10 80 00 22 b 4001d90c <rtems_rfs_dir_del_entry+0x1c4>
4001d888: 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))
4001d88c: 80 a7 20 0a cmp %i4, 0xa
4001d890: 04 80 00 33 ble 4001d95c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001d894: 90 10 20 00 clr %o0
4001d898: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
4001d89c: 80 a7 00 01 cmp %i4, %g1
4001d8a0: 1a 80 00 2f bcc 4001d95c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001d8a4: 80 a4 20 00 cmp %l0, 0
4001d8a8: 02 80 00 2d be 4001d95c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001d8ac: 01 00 00 00 nop
4001d8b0: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
4001d8b4: 80 a0 40 10 cmp %g1, %l0
4001d8b8: 0a 80 00 29 bcs 4001d95c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001d8bc: 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))
4001d8c0: 02 80 00 45 be 4001d9d4 <rtems_rfs_dir_del_entry+0x28c> <== ALWAYS TAKEN
4001d8c4: 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)
4001d8c8: 22 80 00 33 be,a 4001d994 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001d8cc: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
4001d8d0: 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))
4001d8d4: 80 a4 80 0f cmp %l2, %o7 <== NOT EXECUTED
4001d8d8: 1a 80 00 12 bcc 4001d920 <rtems_rfs_dir_del_entry+0x1d8> <== NOT EXECUTED
4001d8dc: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001d8e0: f8 0f 60 08 ldub [ %i5 + 8 ], %i4 <== NOT EXECUTED
4001d8e4: c8 0f 60 09 ldub [ %i5 + 9 ], %g4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001d8e8: e0 0f 40 00 ldub [ %i5 ], %l0 <== NOT EXECUTED
4001d8ec: c6 0f 60 01 ldub [ %i5 + 1 ], %g3 <== NOT EXECUTED
4001d8f0: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 <== NOT EXECUTED
4001d8f4: 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);
4001d8f8: b9 2f 20 08 sll %i4, 8, %i4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001d8fc: 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);
4001d900: b8 17 00 04 or %i4, %g4, %i4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001d904: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4001d908: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001d90c: a0 14 00 03 or %l0, %g3, %l0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d910: 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);
4001d914: a0 14 00 02 or %l0, %g2, %l0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d918: 12 bf ff dd bne 4001d88c <rtems_rfs_dir_del_entry+0x144> <== ALWAYS TAKEN
4001d91c: a0 14 00 01 or %l0, %g1, %l0
entry += elength;
eoffset += elength;
}
if (rc == 0)
4001d920: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001d924: 12 80 00 1d bne 4001d998 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
4001d928: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d92c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001d930: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001d934: 7f ff f8 83 call 4001bb40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001d938: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED
if (rc == ENXIO)
4001d93c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
4001d940: 02 80 00 85 be 4001db54 <rtems_rfs_dir_del_entry+0x40c> <== NOT EXECUTED
4001d944: 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)
4001d948: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d94c: 02 bf ff b3 be 4001d818 <rtems_rfs_dir_del_entry+0xd0> <== NOT EXECUTED
4001d950: 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);
4001d954: 10 80 00 11 b 4001d998 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
4001d958: 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))
4001d95c: 7f ff d9 52 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d960: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001d964: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d968: 22 80 00 0b be,a 4001d994 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001d96c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001d970: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d974: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
4001d978: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d97c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001d980: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
4001d984: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
4001d988: 40 00 19 7d call 40023f7c <printf> <== NOT EXECUTED
4001d98c: 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;
4001d990: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001d994: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001d998: 7f ff fa a8 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d99c: 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);
4001d9a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
4001d9a4: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
4001d9a8: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
4001d9ac: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
4001d9b0: 7f ff f7 79 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001d9b4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001d9b8: 81 c7 e0 08 ret <== NOT EXECUTED
4001d9bc: 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);
4001d9c0: 90 10 00 1b mov %i3, %o0
4001d9c4: 40 00 4b 04 call 400305d4 <.urem>
4001d9c8: 92 10 00 15 mov %l5, %o1
4001d9cc: 10 bf ff 9e b 4001d844 <rtems_rfs_dir_del_entry+0xfc>
4001d9d0: 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);
4001d9d4: 82 07 00 12 add %i4, %l2, %g1
memmove (entry, entry + elength, remaining);
4001d9d8: 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);
4001d9dc: aa 25 40 01 sub %l5, %g1, %l5
memmove (entry, entry + elength, remaining);
4001d9e0: 90 10 00 1d mov %i5, %o0
4001d9e4: 40 00 18 96 call 40023c3c <memmove>
4001d9e8: 94 10 00 15 mov %l5, %o2
memset (entry + remaining, 0xff, elength);
4001d9ec: 92 10 20 ff mov 0xff, %o1
4001d9f0: 94 10 00 1c mov %i4, %o2
4001d9f4: 40 00 18 e4 call 40023d84 <memset>
4001d9f8: 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);
4001d9fc: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
4001da00: c4 0f 60 08 ldub [ %i5 + 8 ], %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001da04: 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);
4001da08: bb 28 a0 08 sll %g2, 8, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001da0c: 13 10 00 00 sethi %hi(0x40000000), %o1
4001da10: 7f ff d9 25 call 40013ea4 <rtems_rfs_trace>
4001da14: ba 17 40 01 or %i5, %g1, %i5
4001da18: 80 8a 20 ff btst 0xff, %o0
4001da1c: 02 80 00 17 be 4001da78 <rtems_rfs_dir_del_entry+0x330> <== ALWAYS TAKEN
4001da20: 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");
4001da24: 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: "
4001da28: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
4001da2c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001da30: 12 80 00 05 bne 4001da44 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
4001da34: 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");
4001da38: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001da3c: 02 80 00 3e be 4001db34 <rtems_rfs_dir_del_entry+0x3ec> <== NOT EXECUTED
4001da40: 1b 10 00 d7 sethi %hi(0x40035c00), %o5 <== NOT EXECUTED
4001da44: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001da48: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001da4c: 02 80 00 3a be 4001db34 <rtems_rfs_dir_del_entry+0x3ec> <== NOT EXECUTED
4001da50: 1b 10 00 d7 sethi %hi(0x40035c00), %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: "
4001da54: 1b 10 00 d1 sethi %hi(0x40034400), %o5 <== NOT EXECUTED
4001da58: 9a 13 60 00 mov %o5, %o5 ! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
4001da5c: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001da60: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001da64: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
4001da68: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001da6c: 40 00 19 44 call 40023f7c <printf> <== NOT EXECUTED
4001da70: 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) &&
4001da74: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
4001da78: ba 38 40 1d xnor %g1, %i5, %i5
4001da7c: 80 a7 60 00 cmp %i5, 0
4001da80: 12 80 00 1f bne 4001dafc <rtems_rfs_dir_del_entry+0x3b4>
4001da84: 80 a4 a0 00 cmp %l2, 0
4001da88: 12 80 00 1d bne 4001dafc <rtems_rfs_dir_del_entry+0x3b4> <== ALWAYS TAKEN
4001da8c: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001da90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001da94: 12 80 00 2a bne 4001db3c <rtems_rfs_dir_del_entry+0x3f4> <== NOT EXECUTED
4001da98: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
4001da9c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001daa0: 12 80 00 28 bne 4001db40 <rtems_rfs_dir_del_entry+0x3f8> <== NOT EXECUTED
4001daa4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001daa8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001daac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001dab0: 7f ff f9 27 call 4001bf4c <rtems_rfs_block_map_shrink> <== NOT EXECUTED
4001dab4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
4001dab8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001dabc: 04 80 00 10 ble 4001dafc <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
4001dac0: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001dac4: 7f ff d8 f8 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001dac8: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001dacc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001dad0: 02 80 00 0c be 4001db00 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
4001dad4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001dad8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001dadc: 40 00 1d 72 call 400250a4 <strerror> <== NOT EXECUTED
4001dae0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001dae4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001dae8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001daec: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001daf0: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001daf4: 40 00 19 22 call 40023f7c <printf> <== NOT EXECUTED
4001daf8: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 400377a0 <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);
4001dafc: 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);
4001db00: 92 07 bf a4 add %fp, -92, %o1
4001db04: 90 10 00 11 mov %l1, %o0
4001db08: 7f ff fa 4c call 4001c438 <rtems_rfs_buffer_handle_release>
4001db0c: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
4001db10: 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);
4001db14: 90 10 00 11 mov %l1, %o0
handle->dirty = false;
4001db18: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001db1c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001db20: c0 27 bf ac clr [ %fp + -84 ]
4001db24: 7f ff f7 1c call 4001b794 <rtems_rfs_block_map_close>
4001db28: 92 07 bf b0 add %fp, -80, %o1
4001db2c: 81 c7 e0 08 ret
4001db30: 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: "
4001db34: 10 bf ff ca b 4001da5c <rtems_rfs_dir_del_entry+0x314> <== NOT EXECUTED
4001db38: 9a 13 61 50 or %o5, 0x150, %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))
4001db3c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001db40: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001db44: 12 bf ff ef bne 4001db00 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
4001db48: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001db4c: 10 bf ff d8 b 4001daac <rtems_rfs_dir_del_entry+0x364> <== NOT EXECUTED
4001db50: 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;
4001db54: 10 bf ff 90 b 4001d994 <rtems_rfs_dir_del_entry+0x24c> <== NOT EXECUTED
4001db58: 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))
4001db5c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001db60: 7f ff d8 d1 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001db64: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001db68: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001db6c: 22 bf ff 8b be,a 4001d998 <rtems_rfs_dir_del_entry+0x250><== NOT EXECUTED
4001db70: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001db74: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
4001db78: 40 00 1d 4b call 400250a4 <strerror> <== NOT EXECUTED
4001db7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001db80: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001db84: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001db88: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001db8c: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001db90: 40 00 18 fb call 40023f7c <printf> <== NOT EXECUTED
4001db94: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 400376a8 <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);
4001db98: 10 bf ff 80 b 4001d998 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
4001db9c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001df54 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
4001df54: 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))
4001df58: 90 10 20 00 clr %o0
4001df5c: 13 20 00 00 sethi %hi(0x80000000), %o1
4001df60: 7f ff d7 d1 call 40013ea4 <rtems_rfs_trace>
4001df64: b4 10 00 18 mov %i0, %i2
4001df68: 80 8a 20 ff btst 0xff, %o0
4001df6c: 12 80 00 0a bne 4001df94 <rtems_rfs_dir_empty+0x40> <== NEVER TAKEN
4001df70: 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);
4001df74: 90 10 00 1a mov %i2, %o0
4001df78: 7f ff f5 a6 call 4001b610 <rtems_rfs_block_map_open>
4001df7c: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001df80: b0 92 20 00 orcc %o0, 0, %i0
4001df84: 04 80 00 0f ble 4001dfc0 <rtems_rfs_dir_empty+0x6c> <== ALWAYS TAKEN
4001df88: 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;
}
4001df8c: 81 c7 e0 08 ret <== NOT EXECUTED
4001df90: 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));
4001df94: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001df98: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001df9c: 40 00 17 f8 call 40023f7c <printf> <== NOT EXECUTED
4001dfa0: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400378d0 <CSWTCH.2+0xce0> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001dfa4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001dfa8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001dfac: 7f ff f5 99 call 4001b610 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001dfb0: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
4001dfb4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001dfb8: 14 bf ff f5 bg 4001df8c <rtems_rfs_dir_empty+0x38> <== NOT EXECUTED
4001dfbc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001dfc0: 92 07 bf b0 add %fp, -80, %o1
4001dfc4: 94 10 20 00 clr %o2
4001dfc8: 96 10 20 00 clr %o3
4001dfcc: 7f ff f6 c0 call 4001bacc <rtems_rfs_block_map_seek>
4001dfd0: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001dfd4: b0 92 20 00 orcc %o0, 0, %i0
4001dfd8: 14 80 00 7d bg 4001e1cc <rtems_rfs_dir_empty+0x278> <== NEVER TAKEN
4001dfdc: 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: "
4001dfe0: 21 10 00 de sethi %hi(0x40037800), %l0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001dfe4: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001dfe8: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001dfec: 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)
4001dff0: 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: "
4001dff4: a0 14 20 f0 or %l0, 0xf0, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001dff8: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001dffc: 90 10 00 1a mov %i2, %o0
4001e000: 92 07 bf a4 add %fp, -92, %o1
4001e004: 7f ff f9 87 call 4001c620 <rtems_rfs_buffer_handle_request>
4001e008: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001e00c: b0 92 20 00 orcc %o0, 0, %i0
4001e010: 14 80 00 4d bg 4001e144 <rtems_rfs_dir_empty+0x1f0> <== NEVER TAKEN
4001e014: 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))
4001e018: da 06 a0 08 ld [ %i2 + 8 ], %o5
4001e01c: 9a 83 7f f6 addcc %o5, -10, %o5
4001e020: 02 80 00 5f be 4001e19c <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
4001e024: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e028: fa 08 60 08 ldub [ %g1 + 8 ], %i5
4001e02c: f6 08 60 09 ldub [ %g1 + 9 ], %i3
eino = rtems_rfs_dir_entry_ino (entry);
4001e030: f8 08 40 00 ldub [ %g1 ], %i4
4001e034: c8 08 60 02 ldub [ %g1 + 2 ], %g4
4001e038: c6 08 60 03 ldub [ %g1 + 3 ], %g3
4001e03c: 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);
4001e040: bb 2f 60 08 sll %i5, 8, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001e044: 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);
4001e048: ba 17 40 1b or %i5, %i3, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001e04c: 89 29 20 08 sll %g4, 8, %g4
4001e050: 85 28 a0 10 sll %g2, 0x10, %g2
4001e054: b8 17 00 04 or %i4, %g4, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e058: 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);
4001e05c: b8 17 00 03 or %i4, %g3, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e060: 02 80 00 4f be 4001e19c <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
4001e064: b8 17 00 02 or %i4, %g2, %i4
4001e068: 10 80 00 20 b 4001e0e8 <rtems_rfs_dir_empty+0x194>
4001e06c: 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] != '.')) &&
4001e070: 12 80 00 31 bne 4001e134 <rtems_rfs_dir_empty+0x1e0>
4001e074: 80 a0 00 18 cmp %g0, %i0
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
4001e078: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001e07c: 80 a0 a0 2e cmp %g2, 0x2e
4001e080: 12 80 00 2d bne 4001e134 <rtems_rfs_dir_empty+0x1e0> <== NEVER TAKEN
4001e084: 80 a0 00 18 cmp %g0, %i0
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001e088: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
4001e08c: 80 a0 a0 2e cmp %g2, 0x2e
4001e090: 12 80 00 29 bne 4001e134 <rtems_rfs_dir_empty+0x1e0> <== NEVER TAKEN
4001e094: 80 a0 00 18 cmp %g0, %i0
empty = false;
break;
}
entry += elength;
offset += elength;
4001e098: 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))
4001e09c: 80 a6 c0 0d cmp %i3, %o5
4001e0a0: 1a 80 00 3f bcc 4001e19c <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
4001e0a4: 82 00 40 1d add %g1, %i5, %g1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e0a8: fa 08 60 08 ldub [ %g1 + 8 ], %i5
4001e0ac: de 08 60 09 ldub [ %g1 + 9 ], %o7
eino = rtems_rfs_dir_entry_ino (entry);
4001e0b0: f8 08 40 00 ldub [ %g1 ], %i4
4001e0b4: c8 08 60 01 ldub [ %g1 + 1 ], %g4
4001e0b8: c6 08 60 03 ldub [ %g1 + 3 ], %g3
4001e0bc: 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);
4001e0c0: bb 2f 60 08 sll %i5, 8, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001e0c4: 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);
4001e0c8: ba 17 40 0f or %i5, %o7, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001e0cc: 89 29 20 10 sll %g4, 0x10, %g4
4001e0d0: 85 28 a0 08 sll %g2, 8, %g2
4001e0d4: b8 17 00 04 or %i4, %g4, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e0d8: 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);
4001e0dc: b8 17 00 03 or %i4, %g3, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e0e0: 02 80 00 2f be 4001e19c <rtems_rfs_dir_empty+0x248>
4001e0e4: b8 17 00 02 or %i4, %g2, %i4
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001e0e8: 80 a7 60 0a cmp %i5, 0xa
4001e0ec: 04 80 00 21 ble 4001e170 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001e0f0: 90 10 20 01 mov 1, %o0
4001e0f4: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
4001e0f8: 80 a7 40 02 cmp %i5, %g2
4001e0fc: 1a 80 00 1d bcc 4001e170 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001e100: 80 a7 20 00 cmp %i4, 0
4001e104: 02 80 00 1b be 4001e170 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001e108: 01 00 00 00 nop
4001e10c: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
4001e110: 80 a0 80 1c cmp %g2, %i4
4001e114: 0a 80 00 17 bcs 4001e170 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001e118: 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)) ||
4001e11c: 12 bf ff d5 bne 4001e070 <rtems_rfs_dir_empty+0x11c>
4001e120: 80 a7 60 0c cmp %i5, 0xc
4001e124: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001e128: 80 a0 a0 2e cmp %g2, 0x2e
4001e12c: 02 bf ff db be 4001e098 <rtems_rfs_dir_empty+0x144> <== ALWAYS TAKEN
4001e130: 80 a0 00 18 cmp %g0, %i0
4001e134: 82 60 3f ff subx %g0, -1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
4001e138: 80 88 60 ff btst 0xff, %g1
4001e13c: 32 80 00 02 bne,a 4001e144 <rtems_rfs_dir_empty+0x1f0> <== ALWAYS TAKEN
4001e140: 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);
4001e144: 92 07 bf a4 add %fp, -92, %o1
4001e148: 7f ff f8 bc call 4001c438 <rtems_rfs_buffer_handle_release>
4001e14c: 90 10 00 1a mov %i2, %o0
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001e150: 90 10 00 1a mov %i2, %o0
handle->dirty = false;
4001e154: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001e158: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001e15c: c0 27 bf ac clr [ %fp + -84 ]
4001e160: 7f ff f5 8d call 4001b794 <rtems_rfs_block_map_close>
4001e164: 92 07 bf b0 add %fp, -80, %o1
4001e168: 81 c7 e0 08 ret
4001e16c: 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))
4001e170: 7f ff d7 4d call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e174: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e178: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e17c: 02 80 00 09 be 4001e1a0 <rtems_rfs_dir_empty+0x24c> <== NOT EXECUTED
4001e180: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
4001e184: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001e188: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001e18c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001e190: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4001e194: 40 00 17 7a call 40023f7c <printf> <== NOT EXECUTED
4001e198: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001e19c: 90 10 00 1a mov %i2, %o0
4001e1a0: 92 07 bf b0 add %fp, -80, %o1
4001e1a4: 7f ff f6 67 call 4001bb40 <rtems_rfs_block_map_next_block>
4001e1a8: 94 07 bf a0 add %fp, -96, %o2
if (rc > 0)
4001e1ac: b0 92 20 00 orcc %o0, 0, %i0
4001e1b0: 04 bf ff 93 ble 4001dffc <rtems_rfs_dir_empty+0xa8> <== NEVER TAKEN
4001e1b4: d4 07 bf a0 ld [ %fp + -96 ], %o2
{
if (rc == ENXIO)
rc = 0;
4001e1b8: 82 1e 20 06 xor %i0, 6, %g1
4001e1bc: 80 a0 00 01 cmp %g0, %g1
4001e1c0: 82 60 20 00 subx %g0, 0, %g1
4001e1c4: 10 bf ff e0 b 4001e144 <rtems_rfs_dir_empty+0x1f0>
4001e1c8: 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);
4001e1cc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001e1d0: 7f ff f5 71 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e1d4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001e1d8: 81 c7 e0 08 ret <== NOT EXECUTED
4001e1dc: 81 e8 00 00 restore <== NOT EXECUTED
40022578 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
40022578: 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;
4002257c: 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)
40022580: 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;
40022584: 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)
40022588: 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;
4002258c: 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)
40022590: 84 10 00 04 mov %g4, %g2
40022594: 08 80 00 4b bleu 400226c0 <rtems_rfs_dir_hash+0x148>
40022598: 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;
4002259c: 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;
400225a0: fa 08 60 03 ldub [ %g1 + 3 ], %i5
b += k[4];
b += ((uint32_t)k[5])<<8;
400225a4: d8 08 60 05 ldub [ %g1 + 5 ], %o4
b += ((uint32_t)k[6])<<16;
400225a8: 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];
400225ac: 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;
400225b0: d4 08 60 07 ldub [ %g1 + 7 ], %o2
c += k[8];
c += ((uint32_t)k[9])<<8;
400225b4: d6 08 60 09 ldub [ %g1 + 9 ], %o3
c += ((uint32_t)k[10])<<16;
400225b8: 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];
400225bc: 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;
400225c0: de 08 60 01 ldub [ %g1 + 1 ], %o7
a += ((uint32_t)k[2])<<16;
400225c4: 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];
400225c8: 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;
400225cc: 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;
400225d0: bb 2f 60 18 sll %i5, 0x18, %i5
b += k[4];
b += ((uint32_t)k[5])<<8;
400225d4: 99 2b 20 08 sll %o4, 8, %o4
b += ((uint32_t)k[6])<<16;
400225d8: 91 2a 20 10 sll %o0, 0x10, %o0
b += ((uint32_t)k[7])<<24;
400225dc: 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];
400225e0: 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;
400225e4: 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;
400225e8: 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;
400225ec: 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;
400225f0: 98 03 00 0a add %o4, %o2, %o4
b += ((uint32_t)k[7])<<24;
c += k[8];
400225f4: 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;
400225f8: 84 03 00 02 add %o4, %g2, %g2
c += k[8];
c += ((uint32_t)k[9])<<8;
400225fc: 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;
40022600: 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;
40022604: 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;
40022608: 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;
4002260c: 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];
40022610: 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);
40022614: 88 06 00 02 add %i0, %g2, %g4
40022618: 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;
4002261c: b6 06 c0 1a add %i3, %i2, %i3
a += ((uint32_t)k[2])<<16;
40022620: 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);
40022624: 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;
40022628: 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);
4002262c: ba 17 00 1d or %i4, %i5, %i5
40022630: 86 06 00 03 add %i0, %g3, %g3
40022634: b8 18 c0 1d xor %g3, %i5, %i4
40022638: 86 07 00 04 add %i4, %g4, %g3
4002263c: 84 20 80 1c sub %g2, %i4, %g2
40022640: bb 2f 20 06 sll %i4, 6, %i5
40022644: b9 37 20 1a srl %i4, 0x1a, %i4
40022648: ba 17 40 1c or %i5, %i4, %i5
4002264c: ba 1f 40 02 xor %i5, %g2, %i5
40022650: 84 07 40 03 add %i5, %g3, %g2
40022654: 88 21 00 1d sub %g4, %i5, %g4
40022658: b9 2f 60 08 sll %i5, 8, %i4
4002265c: bb 37 60 18 srl %i5, 0x18, %i5
40022660: ba 17 00 1d or %i4, %i5, %i5
40022664: 88 1f 40 04 xor %i5, %g4, %g4
40022668: b0 01 00 02 add %g4, %g2, %i0
4002266c: bb 29 20 10 sll %g4, 0x10, %i5
40022670: 86 20 c0 04 sub %g3, %g4, %g3
40022674: 89 31 20 10 srl %g4, 0x10, %g4
40022678: 88 17 40 04 or %i5, %g4, %g4
4002267c: 86 19 00 03 xor %g4, %g3, %g3
40022680: bb 28 e0 13 sll %g3, 0x13, %i5
40022684: 89 30 e0 0d srl %g3, 0xd, %g4
40022688: 88 17 40 04 or %i5, %g4, %g4
4002268c: 84 20 80 03 sub %g2, %g3, %g2
length -= 12;
40022690: 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);
40022694: 84 19 00 02 xor %g4, %g2, %g2
40022698: 86 00 c0 18 add %g3, %i0, %g3
4002269c: bb 28 a0 04 sll %g2, 4, %i5
400226a0: b0 26 00 02 sub %i0, %g2, %i0
400226a4: 89 30 a0 1c srl %g2, 0x1c, %g4
length -= 12;
k += 12;
400226a8: 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);
400226ac: 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)
400226b0: 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);
400226b4: 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)
400226b8: 18 bf ff b9 bgu 4002259c <rtems_rfs_dir_hash+0x24> <== NEVER TAKEN
400226bc: 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 */
400226c0: b3 2e 60 02 sll %i1, 2, %i1
400226c4: 3b 10 00 89 sethi %hi(0x40022400), %i5
400226c8: ba 17 61 44 or %i5, 0x144, %i5 ! 40022544 <rtems_rfs_buffer_bdbuf_release+0x8c>
400226cc: fa 07 40 19 ld [ %i5 + %i1 ], %i5
400226d0: 81 c7 40 00 jmp %i5
400226d4: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
400226d8: fa 08 60 0b ldub [ %g1 + 0xb ], %i5
400226dc: bb 2f 60 18 sll %i5, 0x18, %i5
400226e0: 88 01 00 1d add %g4, %i5, %g4
case 11: c+=((uint32_t)k[10])<<16;
400226e4: fa 08 60 0a ldub [ %g1 + 0xa ], %i5
400226e8: bb 2f 60 10 sll %i5, 0x10, %i5
400226ec: 88 01 00 1d add %g4, %i5, %g4
case 10: c+=((uint32_t)k[9])<<8;
400226f0: fa 08 60 09 ldub [ %g1 + 9 ], %i5
400226f4: bb 2f 60 08 sll %i5, 8, %i5
400226f8: 88 01 00 1d add %g4, %i5, %g4
case 9 : c+=k[8];
400226fc: fa 08 60 08 ldub [ %g1 + 8 ], %i5
40022700: 88 01 00 1d add %g4, %i5, %g4
case 8 : b+=((uint32_t)k[7])<<24;
40022704: fa 08 60 07 ldub [ %g1 + 7 ], %i5
40022708: bb 2f 60 18 sll %i5, 0x18, %i5
4002270c: 84 00 80 1d add %g2, %i5, %g2
case 7 : b+=((uint32_t)k[6])<<16;
40022710: fa 08 60 06 ldub [ %g1 + 6 ], %i5
40022714: bb 2f 60 10 sll %i5, 0x10, %i5
40022718: 84 00 80 1d add %g2, %i5, %g2
case 6 : b+=((uint32_t)k[5])<<8;
4002271c: fa 08 60 05 ldub [ %g1 + 5 ], %i5
40022720: bb 2f 60 08 sll %i5, 8, %i5
40022724: 84 00 80 1d add %g2, %i5, %g2
case 5 : b+=k[4];
40022728: fa 08 60 04 ldub [ %g1 + 4 ], %i5
4002272c: 84 00 80 1d add %g2, %i5, %g2
case 4 : a+=((uint32_t)k[3])<<24;
40022730: fa 08 60 03 ldub [ %g1 + 3 ], %i5
40022734: bb 2f 60 18 sll %i5, 0x18, %i5
40022738: 86 00 c0 1d add %g3, %i5, %g3
case 3 : a+=((uint32_t)k[2])<<16;
4002273c: fa 08 60 02 ldub [ %g1 + 2 ], %i5
40022740: bb 2f 60 10 sll %i5, 0x10, %i5
40022744: 86 00 c0 1d add %g3, %i5, %g3
case 2 : a+=((uint32_t)k[1])<<8;
40022748: fa 08 60 01 ldub [ %g1 + 1 ], %i5
4002274c: bb 2f 60 08 sll %i5, 8, %i5
40022750: 86 00 c0 1d add %g3, %i5, %g3
case 1 : a+=k[0];
40022754: c2 08 40 00 ldub [ %g1 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
40022758: 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];
4002275c: 86 00 c0 01 add %g3, %g1, %g3
break;
case 0 : return c;
}
}
final(a,b,c);
40022760: 83 28 a0 0e sll %g2, 0xe, %g1
40022764: 82 17 40 01 or %i5, %g1, %g1
40022768: 88 19 00 02 xor %g4, %g2, %g4
4002276c: 88 21 00 01 sub %g4, %g1, %g4
40022770: bb 29 20 0b sll %g4, 0xb, %i5
40022774: 83 31 20 15 srl %g4, 0x15, %g1
40022778: 82 17 40 01 or %i5, %g1, %g1
4002277c: 86 19 00 03 xor %g4, %g3, %g3
40022780: 86 20 c0 01 sub %g3, %g1, %g3
40022784: bb 28 e0 19 sll %g3, 0x19, %i5
40022788: 83 30 e0 07 srl %g3, 7, %g1
4002278c: 82 17 40 01 or %i5, %g1, %g1
40022790: 84 18 c0 02 xor %g3, %g2, %g2
40022794: 84 20 80 01 sub %g2, %g1, %g2
40022798: bb 28 a0 10 sll %g2, 0x10, %i5
4002279c: 83 30 a0 10 srl %g2, 0x10, %g1
400227a0: 82 17 40 01 or %i5, %g1, %g1
400227a4: 88 18 80 04 xor %g2, %g4, %g4
400227a8: 88 21 00 01 sub %g4, %g1, %g4
400227ac: bb 29 20 04 sll %g4, 4, %i5
400227b0: 83 31 20 1c srl %g4, 0x1c, %g1
400227b4: 82 17 40 01 or %i5, %g1, %g1
400227b8: 86 19 00 03 xor %g4, %g3, %g3
400227bc: 86 20 c0 01 sub %g3, %g1, %g3
400227c0: 84 18 c0 02 xor %g3, %g2, %g2
400227c4: 83 28 e0 0e sll %g3, 0xe, %g1
400227c8: 87 30 e0 12 srl %g3, 0x12, %g3
400227cc: 86 10 40 03 or %g1, %g3, %g3
400227d0: 84 20 80 03 sub %g2, %g3, %g2
400227d4: 88 18 80 04 xor %g2, %g4, %g4
400227d8: b1 28 a0 18 sll %g2, 0x18, %i0
400227dc: 85 30 a0 08 srl %g2, 8, %g2
400227e0: 84 16 00 02 or %i0, %g2, %g2
400227e4: 88 21 00 02 sub %g4, %g2, %g4
return c;
}
400227e8: 81 c7 e0 08 ret
400227ec: 91 e8 00 04 restore %g0, %g4, %o0
4001cde8 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
4001cde8: 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))
4001cdec: 90 10 20 00 clr %o0
4001cdf0: 13 01 00 00 sethi %hi(0x4000000), %o1
4001cdf4: 7f ff dc 2c call 40013ea4 <rtems_rfs_trace>
4001cdf8: a2 10 00 18 mov %i0, %l1
4001cdfc: 80 8a 20 ff btst 0xff, %o0
4001ce00: 12 80 00 1c bne 4001ce70 <rtems_rfs_dir_lookup_ino+0x88> <== NEVER TAKEN
4001ce04: 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;
4001ce08: c0 27 00 00 clr [ %i4 ]
*offset = 0;
4001ce0c: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001ce10: 90 10 00 11 mov %l1, %o0
4001ce14: 7f ff f9 ff call 4001b610 <rtems_rfs_block_map_open>
4001ce18: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001ce1c: b0 92 20 00 orcc %o0, 0, %i0
4001ce20: 24 80 00 30 ble,a 4001cee0 <rtems_rfs_dir_lookup_ino+0xf8><== ALWAYS TAKEN
4001ce24: 92 10 00 1b mov %i3, %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001ce28: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ce2c: 7f ff dc 1e call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001ce30: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001ce34: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ce38: 32 80 00 04 bne,a 4001ce48 <rtems_rfs_dir_lookup_ino+0x60><== NOT EXECUTED
4001ce3c: 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;
}
4001ce40: 81 c7 e0 08 ret <== NOT EXECUTED
4001ce44: 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",
4001ce48: 40 00 20 97 call 400250a4 <strerror> <== NOT EXECUTED
4001ce4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ce50: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001ce54: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001ce58: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001ce5c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001ce60: 40 00 1c 47 call 40023f7c <printf> <== NOT EXECUTED
4001ce64: 90 12 22 80 or %o0, 0x280, %o0 ! 40037280 <CSWTCH.2+0x690><== NOT EXECUTED
4001ce68: 81 c7 e0 08 ret <== NOT EXECUTED
4001ce6c: 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=",
4001ce70: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001ce74: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001ce78: 40 00 1c 41 call 40023f7c <printf> <== NOT EXECUTED
4001ce7c: 90 12 22 38 or %o0, 0x238, %o0 ! 40037238 <CSWTCH.2+0x648><== NOT EXECUTED
4001ce80: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
4001ce84: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
4001ce88: 04 80 00 08 ble 4001cea8 <rtems_rfs_dir_lookup_ino+0xc0> <== NOT EXECUTED
4001ce8c: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
4001ce90: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED
4001ce94: 40 00 1c a4 call 40024124 <putchar> <== NOT EXECUTED
4001ce98: 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++)
4001ce9c: 80 a6 00 10 cmp %i0, %l0 <== NOT EXECUTED
4001cea0: 32 bf ff fd bne,a 4001ce94 <rtems_rfs_dir_lookup_ino+0xac><== NOT EXECUTED
4001cea4: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
4001cea8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001ceac: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001ceb0: 40 00 1c 33 call 40023f7c <printf> <== NOT EXECUTED
4001ceb4: 90 12 22 70 or %o0, 0x270, %o0 ! 40037270 <CSWTCH.2+0x680><== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
4001ceb8: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
4001cebc: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001cec0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001cec4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001cec8: 7f ff f9 d2 call 4001b610 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001cecc: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
4001ced0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001ced4: 14 bf ff d6 bg 4001ce2c <rtems_rfs_dir_lookup_ino+0x44> <== NOT EXECUTED
4001ced8: 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);
4001cedc: 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;
4001cee0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001cee4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001cee8: c0 27 bf ac clr [ %fp + -84 ]
4001ceec: 40 00 15 a3 call 40022578 <rtems_rfs_dir_hash>
4001cef0: 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);
4001cef4: 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);
4001cef8: 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);
4001cefc: 94 10 20 00 clr %o2
4001cf00: 90 10 00 11 mov %l1, %o0
4001cf04: 96 10 20 00 clr %o3
4001cf08: 7f ff fa f1 call 4001bacc <rtems_rfs_block_map_seek>
4001cf0c: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001cf10: b0 92 20 00 orcc %o0, 0, %i0
4001cf14: 04 80 00 15 ble 4001cf68 <rtems_rfs_dir_lookup_ino+0x180> <== ALWAYS TAKEN
4001cf18: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001cf1c: 7f ff db e2 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001cf20: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001cf24: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001cf28: 12 80 00 bf bne 4001d224 <rtems_rfs_dir_lookup_ino+0x43c> <== NOT EXECUTED
4001cf2c: 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)
4001cf30: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
4001cf34: 22 80 00 02 be,a 4001cf3c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001cf38: 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);
4001cf3c: 92 07 bf a4 add %fp, -92, %o1
4001cf40: 7f ff fd 3e call 4001c438 <rtems_rfs_buffer_handle_release>
4001cf44: 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);
4001cf48: 90 10 00 11 mov %l1, %o0
handle->dirty = false;
4001cf4c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001cf50: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001cf54: c0 27 bf ac clr [ %fp + -84 ]
4001cf58: 7f ff fa 0f call 4001b794 <rtems_rfs_block_map_close>
4001cf5c: 92 07 bf b0 add %fp, -80, %o1
4001cf60: 81 c7 e0 08 ret
4001cf64: 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",
4001cf68: 2d 10 00 dc sethi %hi(0x40037000), %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)
4001cf6c: 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: "
4001cf70: 2b 10 00 dc sethi %hi(0x40037000), %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",
4001cf74: ac 15 a3 00 or %l6, 0x300, %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)
4001cf78: 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: "
4001cf7c: aa 15 63 d0 or %l5, 0x3d0, %l5
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001cf80: 80 a6 20 00 cmp %i0, 0
4001cf84: 12 80 00 6b bne 4001d130 <rtems_rfs_dir_lookup_ino+0x348> <== NEVER TAKEN
4001cf88: c2 07 bf a0 ld [ %fp + -96 ], %g1
4001cf8c: 80 a0 60 00 cmp %g1, 0
4001cf90: 02 80 00 d3 be 4001d2dc <rtems_rfs_dir_lookup_ino+0x4f4> <== NEVER TAKEN
4001cf94: 90 10 20 00 clr %o0
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001cf98: 7f ff db c3 call 40013ea4 <rtems_rfs_trace>
4001cf9c: 13 01 00 00 sethi %hi(0x4000000), %o1
4001cfa0: 80 8a 20 ff btst 0xff, %o0
4001cfa4: 32 80 00 87 bne,a 4001d1c0 <rtems_rfs_dir_lookup_ino+0x3d8><== NEVER TAKEN
4001cfa8: 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);
4001cfac: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001cfb0: 90 10 00 11 mov %l1, %o0
4001cfb4: 92 07 bf a4 add %fp, -92, %o1
4001cfb8: 7f ff fd 9a call 4001c620 <rtems_rfs_buffer_handle_request>
4001cfbc: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001cfc0: a8 92 20 00 orcc %o0, 0, %l4
4001cfc4: 14 80 00 b3 bg 4001d290 <rtems_rfs_dir_lookup_ino+0x4a8> <== NEVER TAKEN
4001cfc8: 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))
4001cfcc: d8 04 60 08 ld [ %l1 + 8 ], %o4
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
4001cfd0: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001cfd4: 80 a3 20 0a cmp %o4, 0xa
4001cfd8: 12 80 00 0a bne 4001d000 <rtems_rfs_dir_lookup_ino+0x218> <== ALWAYS TAKEN
4001cfdc: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001cfe0: 10 80 00 47 b 4001d0fc <rtems_rfs_dir_lookup_ino+0x314> <== NOT EXECUTED
4001cfe4: 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))
4001cfe8: 86 03 3f f6 add %o4, -10, %g3
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
4001cfec: 84 05 c0 02 add %l7, %g2, %g2
4001cff0: 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))
4001cff4: 80 a0 c0 02 cmp %g3, %g2
4001cff8: 08 80 00 40 bleu 4001d0f8 <rtems_rfs_dir_lookup_ino+0x310><== NEVER TAKEN
4001cffc: 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);
4001d000: c4 0c 00 00 ldub [ %l0 ], %g2
4001d004: d0 0c 20 01 ldub [ %l0 + 1 ], %o0
4001d008: d2 0c 20 03 ldub [ %l0 + 3 ], %o1
4001d00c: 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);
4001d010: d6 0c 20 04 ldub [ %l0 + 4 ], %o3
4001d014: c8 0c 20 05 ldub [ %l0 + 5 ], %g4
4001d018: da 0c 20 07 ldub [ %l0 + 7 ], %o5
4001d01c: c6 0c 20 06 ldub [ %l0 + 6 ], %g3
elength = rtems_rfs_dir_entry_length (entry);
4001d020: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
4001d024: de 0c 20 09 ldub [ %l0 + 9 ], %o7
*ino = rtems_rfs_dir_entry_ino (entry);
4001d028: 85 28 a0 18 sll %g2, 0x18, %g2
4001d02c: 91 2a 20 10 sll %o0, 0x10, %o0
4001d030: 95 2a a0 08 sll %o2, 8, %o2
4001d034: 84 10 80 08 or %g2, %o0, %g2
4001d038: 84 10 80 09 or %g2, %o1, %g2
4001d03c: 84 10 80 0a or %g2, %o2, %g2
4001d040: 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);
4001d044: 97 2a e0 18 sll %o3, 0x18, %o3
4001d048: 89 29 20 10 sll %g4, 0x10, %g4
4001d04c: 87 28 e0 08 sll %g3, 8, %g3
4001d050: 88 12 c0 04 or %o3, %g4, %g4
elength = rtems_rfs_dir_entry_length (entry);
4001d054: 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);
4001d058: 88 11 00 0d or %g4, %o5, %g4
elength = rtems_rfs_dir_entry_length (entry);
4001d05c: ae 10 40 0f or %g1, %o7, %l7
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001d060: 80 a5 c0 12 cmp %l7, %l2
4001d064: 02 80 00 25 be 4001d0f8 <rtems_rfs_dir_lookup_ino+0x310>
4001d068: 86 11 00 03 or %g4, %g3, %g3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
4001d06c: 80 a5 e0 0a cmp %l7, 0xa
4001d070: 24 80 00 34 ble,a 4001d140 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001d074: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d078: de 04 60 1c ld [ %l1 + 0x1c ], %o7
4001d07c: 80 a5 c0 0f cmp %l7, %o7
4001d080: 1a 80 00 2f bcc 4001d13c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001d084: 80 a0 a0 00 cmp %g2, 0
4001d088: 22 80 00 2e be,a 4001d140 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001d08c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d090: c8 04 60 14 ld [ %l1 + 0x14 ], %g4
4001d094: 80 a0 80 04 cmp %g2, %g4
4001d098: 18 80 00 29 bgu 4001d13c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001d09c: 80 a0 c0 13 cmp %g3, %l3
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
4001d0a0: 12 bf ff d2 bne 4001cfe8 <rtems_rfs_dir_lookup_ino+0x200>
4001d0a4: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001d0a8: 90 10 20 00 clr %o0
4001d0ac: 7f ff db 7e call 40013ea4 <rtems_rfs_trace>
4001d0b0: 13 02 00 00 sethi %hi(0x8000000), %o1
4001d0b4: 80 8a 20 ff btst 0xff, %o0
4001d0b8: 32 80 00 32 bne,a 4001d180 <rtems_rfs_dir_lookup_ino+0x398><== NEVER TAKEN
4001d0bc: 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)
4001d0c0: 90 04 20 0a add %l0, 0xa, %o0
4001d0c4: 92 10 00 1a mov %i2, %o1
4001d0c8: 40 00 1a 76 call 40023aa0 <memcmp>
4001d0cc: 94 10 00 1b mov %i3, %o2
4001d0d0: 80 a2 20 00 cmp %o0, 0
4001d0d4: 02 80 00 5d be 4001d248 <rtems_rfs_dir_lookup_ino+0x460> <== ALWAYS TAKEN
4001d0d8: c4 07 bf c4 ld [ %fp + -60 ], %g2
4001d0dc: d8 04 60 08 ld [ %l1 + 8 ], %o4 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
4001d0e0: 84 05 c0 02 add %l7, %g2, %g2 <== NOT EXECUTED
4001d0e4: 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))
4001d0e8: 86 03 3f f6 add %o4, -10, %g3 <== NOT EXECUTED
4001d0ec: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
4001d0f0: 18 bf ff c4 bgu 4001d000 <rtems_rfs_dir_lookup_ino+0x218> <== NOT EXECUTED
4001d0f4: a0 04 00 17 add %l0, %l7, %l0 <== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001d0f8: 80 a5 20 00 cmp %l4, 0
4001d0fc: 32 bf ff 90 bne,a 4001cf3c <rtems_rfs_dir_lookup_ino+0x154><== NEVER TAKEN
4001d100: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001d104: 90 10 00 11 mov %l1, %o0
4001d108: 92 07 bf b0 add %fp, -80, %o1
4001d10c: 7f ff fa 8d call 4001bb40 <rtems_rfs_block_map_next_block>
4001d110: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
4001d114: 80 a2 20 06 cmp %o0, 6
4001d118: 12 80 00 2f bne 4001d1d4 <rtems_rfs_dir_lookup_ino+0x3ec> <== NEVER TAKEN
4001d11c: 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)
4001d120: 80 a6 20 06 cmp %i0, 6
4001d124: 12 bf ff 98 bne 4001cf84 <rtems_rfs_dir_lookup_ino+0x19c> <== NEVER TAKEN
4001d128: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
4001d12c: 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)
4001d130: 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;
4001d134: 10 bf ff 82 b 4001cf3c <rtems_rfs_dir_lookup_ino+0x154>
4001d138: 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))
4001d13c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d140: 7f ff db 59 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d144: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001d148: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d14c: 12 80 00 04 bne 4001d15c <rtems_rfs_dir_lookup_ino+0x374> <== NOT EXECUTED
4001d150: 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;
4001d154: 10 bf ff 7a b 4001cf3c <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
4001d158: 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: "
4001d15c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d160: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001d164: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001d168: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
4001d16c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001d170: 40 00 1b 83 call 40023f7c <printf> <== NOT EXECUTED
4001d174: 90 12 23 80 or %o0, 0x380, %o0 ! 40037380 <CSWTCH.2+0x790><== NOT EXECUTED
4001d178: 10 bf ff 71 b 4001cf3c <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
4001d17c: 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));
4001d180: c4 0c 20 02 ldub [ %l0 + 2 ], %g2 <== NOT EXECUTED
4001d184: da 0c 00 00 ldub [ %l0 ], %o5 <== NOT EXECUTED
4001d188: 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: "
4001d18c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d190: 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));
4001d194: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4001d198: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4001d19c: 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: "
4001d1a0: 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));
4001d1a4: 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: "
4001d1a8: 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));
4001d1ac: 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: "
4001d1b0: 40 00 1b 73 call 40023f7c <printf> <== NOT EXECUTED
4001d1b4: 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)
4001d1b8: 10 bf ff c3 b 4001d0c4 <rtems_rfs_dir_lookup_ino+0x2dc> <== NOT EXECUTED
4001d1bc: 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",
4001d1c0: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
4001d1c4: 40 00 1b 6e call 40023f7c <printf> <== NOT EXECUTED
4001d1c8: 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);
4001d1cc: 10 bf ff 79 b 4001cfb0 <rtems_rfs_dir_lookup_ino+0x1c8> <== NOT EXECUTED
4001d1d0: 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))
4001d1d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d1d8: 04 bf ff d3 ble 4001d124 <rtems_rfs_dir_lookup_ino+0x33c> <== NOT EXECUTED
4001d1dc: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001d1e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d1e4: 7f ff db 30 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d1e8: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001d1ec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d1f0: 22 bf ff cd be,a 4001d124 <rtems_rfs_dir_lookup_ino+0x33c><== NOT EXECUTED
4001d1f4: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001d1f8: e0 06 60 08 ld [ %i1 + 8 ], %l0 <== NOT EXECUTED
4001d1fc: 40 00 1f aa call 400250a4 <strerror> <== NOT EXECUTED
4001d200: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d204: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001d208: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d20c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001d210: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d214: 40 00 1b 5a call 40023f7c <printf> <== NOT EXECUTED
4001d218: 90 12 20 78 or %o0, 0x78, %o0 ! 40037478 <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)
4001d21c: 10 bf ff 5a b 4001cf84 <rtems_rfs_dir_lookup_ino+0x19c> <== NOT EXECUTED
4001d220: 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",
4001d224: 40 00 1f a0 call 400250a4 <strerror> <== NOT EXECUTED
4001d228: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d22c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001d230: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001d234: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001d238: 40 00 1b 51 call 40023f7c <printf> <== NOT EXECUTED
4001d23c: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 400372c0 <CSWTCH.2+0x6d0><== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
4001d240: 10 bf ff 3d b 4001cf34 <rtems_rfs_dir_lookup_ino+0x14c> <== NOT EXECUTED
4001d244: 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);
4001d248: 90 10 00 11 mov %l1, %o0
4001d24c: 7f ff f8 bc call 4001b53c <rtems_rfs_block_get_pos>
4001d250: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001d254: 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);
4001d258: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001d25c: 7f ff db 12 call 40013ea4 <rtems_rfs_trace>
4001d260: 13 04 00 00 sethi %hi(0x10000000), %o1
4001d264: 80 8a 20 ff btst 0xff, %o0
4001d268: 22 bf ff 36 be,a 4001cf40 <rtems_rfs_dir_lookup_ino+0x158><== ALWAYS TAKEN
4001d26c: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
4001d270: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001d274: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4001d278: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001d27c: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001d280: 40 00 1b 3f call 40023f7c <printf> <== NOT EXECUTED
4001d284: 90 12 20 30 or %o0, 0x30, %o0 ! 40037430 <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);
4001d288: 10 bf ff 2e b 4001cf40 <rtems_rfs_dir_lookup_ino+0x158> <== NOT EXECUTED
4001d28c: 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))
4001d290: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d294: 7f ff db 04 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d298: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001d29c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d2a0: 22 bf ff 27 be,a 4001cf3c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001d2a4: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
4001d2a8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001d2ac: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
4001d2b0: 40 00 1f 7d call 400250a4 <strerror> <== NOT EXECUTED
4001d2b4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
4001d2b8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001d2bc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001d2c0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001d2c4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001d2c8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001d2cc: 40 00 1b 2c call 40023f7c <printf> <== NOT EXECUTED
4001d2d0: 90 12 23 38 or %o0, 0x338, %o0 <== NOT EXECUTED
4001d2d4: 10 bf ff 1a b 4001cf3c <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
4001d2d8: 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))
4001d2dc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001d2e0: 7f ff da f1 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001d2e4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001d2e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001d2ec: 22 bf ff 15 be,a 4001cf40 <rtems_rfs_dir_lookup_ino+0x158><== NOT EXECUTED
4001d2f0: 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",
4001d2f4: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
4001d2f8: 40 00 1f 6b call 400250a4 <strerror> <== NOT EXECUTED
4001d2fc: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
4001d300: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001d304: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001d308: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
4001d30c: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
4001d310: 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",
4001d314: 40 00 1b 1a call 40023f7c <printf> <== NOT EXECUTED
4001d318: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
4001d31c: 10 bf ff 09 b 4001cf40 <rtems_rfs_dir_lookup_ino+0x158> <== NOT EXECUTED
4001d320: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001dba0 <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)
{
4001dba0: 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))
4001dba4: 90 10 20 00 clr %o0
4001dba8: 7f ff d8 bf call 40013ea4 <rtems_rfs_trace>
4001dbac: 13 20 00 00 sethi %hi(0x80000000), %o1
4001dbb0: 80 8a 20 ff btst 0xff, %o0
4001dbb4: 32 80 00 27 bne,a 4001dc50 <rtems_rfs_dir_read+0xb0> <== NEVER TAKEN
4001dbb8: 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;
4001dbbc: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001dbc0: 90 10 00 18 mov %i0, %o0
4001dbc4: 92 10 00 19 mov %i1, %o1
4001dbc8: 7f ff f6 92 call 4001b610 <rtems_rfs_block_map_open>
4001dbcc: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001dbd0: a0 92 20 00 orcc %o0, 0, %l0
4001dbd4: 24 80 00 04 ble,a 4001dbe4 <rtems_rfs_dir_read+0x44> <== ALWAYS TAKEN
4001dbd8: e0 06 20 08 ld [ %i0 + 8 ], %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001dbdc: 81 c7 e0 08 ret
4001dbe0: 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))
4001dbe4: 90 10 00 1a mov %i2, %o0
4001dbe8: a2 10 00 10 mov %l0, %l1
4001dbec: 92 10 00 1b mov %i3, %o1
4001dbf0: a0 10 20 00 clr %l0
4001dbf4: 96 10 00 11 mov %l1, %o3
4001dbf8: 40 00 4c 40 call 40030cf8 <__moddi3>
4001dbfc: 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) -
4001dc00: 92 a4 40 09 subcc %l1, %o1, %o1
4001dc04: 90 64 00 08 subx %l0, %o0, %o0
4001dc08: 80 a2 20 00 cmp %o0, 0
4001dc0c: 04 80 00 18 ble 4001dc6c <rtems_rfs_dir_read+0xcc> <== ALWAYS TAKEN
4001dc10: 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);
4001dc14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001dc18: 92 07 bf b0 add %fp, -80, %o1
4001dc1c: 94 10 00 1a mov %i2, %o2
4001dc20: 96 10 00 1b mov %i3, %o3
4001dc24: 7f ff f7 aa call 4001bacc <rtems_rfs_block_map_seek>
4001dc28: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001dc2c: a0 92 20 00 orcc %o0, 0, %l0
4001dc30: 04 80 00 25 ble 4001dcc4 <rtems_rfs_dir_read+0x124> <== ALWAYS TAKEN
4001dc34: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
4001dc38: 02 80 00 1f be 4001dcb4 <rtems_rfs_dir_read+0x114> <== NOT EXECUTED
4001dc3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
4001dc40: 7f ff f6 d5 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001dc44: 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;
}
4001dc48: 81 c7 e0 08 ret <== NOT EXECUTED
4001dc4c: 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",
4001dc50: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001dc54: 11 10 00 dd sethi %hi(0x40037400), %o0 <== NOT EXECUTED
4001dc58: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001dc5c: 40 00 18 c8 call 40023f7c <printf> <== NOT EXECUTED
4001dc60: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
4001dc64: 10 bf ff d7 b 4001dbc0 <rtems_rfs_dir_read+0x20> <== NOT EXECUTED
4001dc68: 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) -
4001dc6c: 32 80 00 06 bne,a 4001dc84 <rtems_rfs_dir_read+0xe4> <== NEVER TAKEN
4001dc70: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001dc74: 80 a2 60 0a cmp %o1, 0xa
4001dc78: 38 bf ff e8 bgu,a 4001dc18 <rtems_rfs_dir_read+0x78> <== ALWAYS TAKEN
4001dc7c: 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) *
4001dc80: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001dc84: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001dc88: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001dc8c: 40 00 4b 30 call 4003094c <__divdi3> <== NOT EXECUTED
4001dc90: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001dc94: 96 82 60 01 addcc %o1, 1, %o3 <== NOT EXECUTED
4001dc98: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001dc9c: 94 42 20 00 addx %o0, 0, %o2 <== NOT EXECUTED
4001dca0: 40 00 4a f9 call 40030884 <__muldi3> <== NOT EXECUTED
4001dca4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001dca8: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
4001dcac: 10 bf ff da b 4001dc14 <rtems_rfs_dir_read+0x74> <== NOT EXECUTED
4001dcb0: 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;
4001dcb4: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001dcb8: 7f ff f6 b7 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001dcbc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001dcc0: 30 bf ff e2 b,a 4001dc48 <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)
4001dcc4: 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",
4001dcc8: 2b 10 00 de sethi %hi(0x40037800), %l5
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001dccc: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001dcd0: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001dcd4: 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)
4001dcd8: 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",
4001dcdc: aa 15 60 98 or %l5, 0x98, %l5
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001dce0: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001dce4: 96 10 20 01 mov 1, %o3
4001dce8: 92 07 bf a4 add %fp, -92, %o1
4001dcec: 7f ff fa 4d call 4001c620 <rtems_rfs_buffer_handle_request>
4001dcf0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001dcf4: a0 92 20 00 orcc %o0, 0, %l0
4001dcf8: 14 80 00 32 bg 4001ddc0 <rtems_rfs_dir_read+0x220> <== NEVER TAKEN
4001dcfc: 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;
4001dd00: 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);
4001dd04: 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))
4001dd08: 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;
4001dd0c: a2 00 40 12 add %g1, %l2, %l1
elength = rtems_rfs_dir_entry_length (entry);
4001dd10: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
4001dd14: e6 0c 60 08 ldub [ %l1 + 8 ], %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001dd18: 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);
4001dd1c: 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))
4001dd20: 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);
4001dd24: a6 14 c0 02 or %l3, %g2, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001dd28: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
4001dd2c: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001dd30: 80 a4 c0 14 cmp %l3, %l4
4001dd34: 12 80 00 2d bne 4001dde8 <rtems_rfs_dir_read+0x248>
4001dd38: 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;
4001dd3c: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001dd40: c2 07 40 00 ld [ %i5 ], %g1
4001dd44: a4 20 80 12 sub %g2, %l2, %l2
4001dd48: a4 00 40 12 add %g1, %l2, %l2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001dd4c: 7f ff d8 56 call 40013ea4 <rtems_rfs_trace>
4001dd50: e4 27 40 00 st %l2, [ %i5 ]
4001dd54: 80 8a 20 ff btst 0xff, %o0
4001dd58: 12 80 00 0d bne 4001dd8c <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
4001dd5c: 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);
4001dd60: 92 07 bf b0 add %fp, -80, %o1
4001dd64: 7f ff f7 77 call 4001bb40 <rtems_rfs_block_map_next_block>
4001dd68: 94 07 bf a0 add %fp, -96, %o2
if (rc == ENXIO)
4001dd6c: 80 a2 20 06 cmp %o0, 6
4001dd70: 02 80 00 13 be 4001ddbc <rtems_rfs_dir_read+0x21c> <== ALWAYS TAKEN
4001dd74: 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)
4001dd78: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001dd7c: 02 bf ff da be 4001dce4 <rtems_rfs_dir_read+0x144> <== NOT EXECUTED
4001dd80: 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);
4001dd84: 10 80 00 10 b 4001ddc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001dd88: 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",
4001dd8c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001dd90: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001dd94: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001dd98: 40 00 18 79 call 40023f7c <printf> <== NOT EXECUTED
4001dd9c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001dda0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001dda4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001dda8: 7f ff f7 66 call 4001bb40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001ddac: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED
if (rc == ENXIO)
4001ddb0: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
4001ddb4: 12 bf ff f1 bne 4001dd78 <rtems_rfs_dir_read+0x1d8> <== NOT EXECUTED
4001ddb8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = ENOENT;
4001ddbc: a0 10 20 02 mov 2, %l0
4001ddc0: 92 07 bf a4 add %fp, -92, %o1
4001ddc4: 7f ff f9 9d call 4001c438 <rtems_rfs_buffer_handle_release>
4001ddc8: 90 10 00 18 mov %i0, %o0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001ddcc: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001ddd0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001ddd4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001ddd8: c0 27 bf ac clr [ %fp + -84 ]
4001dddc: 7f ff f6 6e call 4001b794 <rtems_rfs_block_map_close>
4001dde0: 92 07 bf b0 add %fp, -80, %o1
4001dde4: 30 bf ff 7e b,a 4001dbdc <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);
4001dde8: 89 29 20 18 sll %g4, 0x18, %g4
4001ddec: 86 08 e0 ff and %g3, 0xff, %g3
4001ddf0: 84 08 a0 ff and %g2, 0xff, %g2
4001ddf4: 87 28 e0 10 sll %g3, 0x10, %g3
4001ddf8: 82 08 60 ff and %g1, 0xff, %g1
4001ddfc: 88 11 00 03 or %g4, %g3, %g4
4001de00: 83 28 60 08 sll %g1, 8, %g1
4001de04: 84 11 00 02 or %g4, %g2, %g2
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001de08: 80 a4 e0 0a cmp %l3, 0xa
4001de0c: 04 80 00 0d ble 4001de40 <rtems_rfs_dir_read+0x2a0> <== NEVER TAKEN
4001de10: a8 10 80 01 or %g2, %g1, %l4
4001de14: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001de18: 80 a4 c0 01 cmp %l3, %g1
4001de1c: 1a 80 00 0a bcc 4001de44 <rtems_rfs_dir_read+0x2a4> <== NEVER TAKEN
4001de20: 90 10 20 00 clr %o0
4001de24: 80 a5 20 00 cmp %l4, 0
4001de28: 02 80 00 08 be 4001de48 <rtems_rfs_dir_read+0x2a8> <== NEVER TAKEN
4001de2c: 13 20 00 00 sethi %hi(0x80000000), %o1
4001de30: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001de34: 80 a5 00 01 cmp %l4, %g1
4001de38: 08 80 00 12 bleu 4001de80 <rtems_rfs_dir_read+0x2e0> <== ALWAYS TAKEN
4001de3c: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001de40: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001de44: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
4001de48: 7f ff d8 17 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001de4c: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
4001de50: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001de54: 22 bf ff dc be,a 4001ddc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001de58: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
4001de5c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001de60: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001de64: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4001de68: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001de6c: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001de70: 40 00 18 43 call 40023f7c <printf> <== NOT EXECUTED
4001de74: 90 12 20 18 or %o0, 0x18, %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);
4001de78: 10 bf ff d3 b 4001ddc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001de7c: 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));
4001de80: 92 10 20 00 clr %o1
4001de84: 40 00 17 c0 call 40023d84 <memset>
4001de88: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
4001de8c: c2 07 40 00 ld [ %i5 ], %g1
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
4001de90: 84 10 21 18 mov 0x118, %g2
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
4001de94: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
4001de98: c4 37 20 10 sth %g2, [ %i4 + 0x10 ]
*length += elength;
4001de9c: 82 04 c0 01 add %l3, %g1, %g1
4001dea0: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001dea4: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001dea8: 84 20 80 12 sub %g2, %l2, %g2
4001deac: 84 20 80 13 sub %g2, %l3, %g2
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
4001deb0: 80 a0 a0 0a cmp %g2, 0xa
4001deb4: 14 80 00 04 bg 4001dec4 <rtems_rfs_dir_read+0x324> <== ALWAYS TAKEN
4001deb8: a6 04 ff f6 add %l3, -10, %l3
*length += remaining;
4001debc: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
4001dec0: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
4001dec4: 80 a4 e0 ff cmp %l3, 0xff
4001dec8: 34 80 00 02 bg,a 4001ded0 <rtems_rfs_dir_read+0x330> <== NEVER TAKEN
4001decc: 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);
4001ded0: 92 04 60 0a add %l1, 0xa, %o1
4001ded4: 94 10 00 13 mov %l3, %o2
4001ded8: ba 07 20 14 add %i4, 0x14, %i5
4001dedc: 40 00 17 1b call 40023b48 <memcpy>
4001dee0: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001dee4: c8 0c 40 00 ldub [ %l1 ], %g4
4001dee8: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
4001deec: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
4001def0: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
4001def4: 89 29 20 18 sll %g4, 0x18, %g4
4001def8: 87 28 e0 10 sll %g3, 0x10, %g3
4001defc: 83 28 60 08 sll %g1, 8, %g1
4001df00: 86 11 00 03 or %g4, %g3, %g3
4001df04: 84 10 c0 02 or %g3, %g2, %g2
4001df08: 82 10 80 01 or %g2, %g1, %g1
dirent->d_namlen = elength;
4001df0c: e6 37 20 12 sth %l3, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001df10: 90 10 20 00 clr %o0
4001df14: 13 20 00 00 sethi %hi(0x80000000), %o1
4001df18: 7f ff d7 e3 call 40013ea4 <rtems_rfs_trace>
4001df1c: c2 27 00 00 st %g1, [ %i4 ]
4001df20: 80 8a 20 ff btst 0xff, %o0
4001df24: 22 bf ff a8 be,a 4001ddc4 <rtems_rfs_dir_read+0x224> <== ALWAYS TAKEN
4001df28: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001df2c: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
4001df30: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001df34: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
4001df38: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
4001df3c: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001df40: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
4001df44: 40 00 18 0e call 40023f7c <printf> <== NOT EXECUTED
4001df48: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
4001df4c: 10 bf ff 9e b 4001ddc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001df50: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001e524 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
4001e524: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001e528: 90 10 20 10 mov 0x10, %o0
4001e52c: 92 10 20 00 clr %o1
4001e530: 7f ff d6 5d call 40013ea4 <rtems_rfs_trace>
4001e534: ba 10 00 18 mov %i0, %i5
4001e538: 80 8a 20 ff btst 0xff, %o0
4001e53c: 32 80 00 87 bne,a 4001e758 <rtems_rfs_file_close+0x234> <== NEVER TAKEN
4001e540: 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)
4001e544: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001e548: c2 02 60 08 ld [ %o1 + 8 ], %g1
4001e54c: 80 a0 60 00 cmp %g1, 0
4001e550: 04 80 00 04 ble 4001e560 <rtems_rfs_file_close+0x3c> <== NEVER TAKEN
4001e554: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
4001e558: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
4001e55c: 80 a0 60 00 cmp %g1, 0
4001e560: 12 80 00 74 bne 4001e730 <rtems_rfs_file_close+0x20c> <== NEVER TAKEN
4001e564: 90 10 00 1d mov %i5, %o0
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
4001e568: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001e56c: 80 a0 60 00 cmp %g1, 0
4001e570: 22 80 00 a7 be,a 4001e80c <rtems_rfs_file_close+0x2e8> <== ALWAYS TAKEN
4001e574: 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,
4001e578: 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);
4001e57c: 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);
4001e580: 89 30 a0 18 srl %g2, 0x18, %g4
4001e584: c8 28 60 10 stb %g4, [ %g1 + 0x10 ]
4001e588: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001e58c: 89 30 a0 10 srl %g2, 0x10, %g4
4001e590: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
4001e594: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001e598: 89 30 a0 08 srl %g2, 8, %g4
4001e59c: c8 28 60 12 stb %g4, [ %g1 + 0x12 ]
4001e5a0: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001e5a4: c4 28 60 13 stb %g2, [ %g1 + 0x13 ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
4001e5a8: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001e5ac: c6 2a 60 1c stb %g3, [ %o1 + 0x1c ]
4001e5b0: 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);
4001e5b4: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001e5b8: b9 30 60 18 srl %g1, 0x18, %i4
4001e5bc: f8 29 20 14 stb %i4, [ %g4 + 0x14 ]
4001e5c0: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001e5c4: b9 30 60 10 srl %g1, 0x10, %i4
4001e5c8: f8 29 20 15 stb %i4, [ %g4 + 0x15 ]
4001e5cc: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001e5d0: b9 30 60 08 srl %g1, 8, %i4
4001e5d4: f8 29 20 16 stb %i4, [ %g4 + 0x16 ]
4001e5d8: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001e5dc: c2 29 20 17 stb %g1, [ %g4 + 0x17 ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
4001e5e0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001e5e4: 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);
4001e5e8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001e5ec: c4 00 60 94 ld [ %g1 + 0x94 ], %g2
4001e5f0: b9 30 a0 18 srl %g2, 0x18, %i4
4001e5f4: f8 29 20 18 stb %i4, [ %g4 + 0x18 ]
4001e5f8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001e5fc: b9 30 a0 10 srl %g2, 0x10, %i4
4001e600: f8 29 20 19 stb %i4, [ %g4 + 0x19 ]
4001e604: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001e608: b9 30 a0 08 srl %g2, 8, %i4
4001e60c: f8 29 20 1a stb %i4, [ %g4 + 0x1a ]
4001e610: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001e614: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001e618: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001e61c: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
4001e620: c4 02 60 3c ld [ %o1 + 0x3c ], %g2
4001e624: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
4001e628: 80 a0 40 02 cmp %g1, %g2
4001e62c: 02 80 00 72 be 4001e7f4 <rtems_rfs_file_close+0x2d0> <== ALWAYS TAKEN
4001e630: 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);
4001e634: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED
4001e638: c4 22 60 40 st %g2, [ %o1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001e63c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001e640: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001e644: 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);
4001e648: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e64c: 7f ff f4 52 call 4001b794 <rtems_rfs_block_map_close>
4001e650: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001e654: b8 92 20 00 orcc %o0, 0, %i4
4001e658: 04 80 00 0a ble 4001e680 <rtems_rfs_file_close+0x15c> <== ALWAYS TAKEN
4001e65c: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001e660: 7f ff d6 11 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e664: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e668: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e66c: 32 80 00 57 bne,a 4001e7c8 <rtems_rfs_file_close+0x2a4> <== NOT EXECUTED
4001e670: 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)
4001e674: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001e678: 22 80 00 02 be,a 4001e680 <rtems_rfs_file_close+0x15c> <== NOT EXECUTED
4001e67c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001e680: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001e684: 90 10 00 1d mov %i5, %o0
4001e688: 7f ff cf d8 call 400125e8 <rtems_rfs_inode_close>
4001e68c: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
4001e690: b8 92 20 00 orcc %o0, 0, %i4
4001e694: 04 80 00 0a ble 4001e6bc <rtems_rfs_file_close+0x198> <== ALWAYS TAKEN
4001e698: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001e69c: 7f ff d6 02 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e6a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e6a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e6a8: 32 80 00 3d bne,a 4001e79c <rtems_rfs_file_close+0x278> <== NOT EXECUTED
4001e6ac: 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)
4001e6b0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001e6b4: 22 80 00 2f be,a 4001e770 <rtems_rfs_file_close+0x24c> <== NOT EXECUTED
4001e6b8: 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 );
4001e6bc: 7f ff ea e8 call 4001925c <_Chain_Extract>
4001e6c0: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
4001e6c4: 7f ff a6 21 call 40007f48 <free>
4001e6c8: 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);
4001e6cc: 90 10 00 1d mov %i5, %o0
4001e6d0: 7f ff f7 5a call 4001c438 <rtems_rfs_buffer_handle_release>
4001e6d4: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
4001e6d8: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
4001e6dc: 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)
4001e6e0: 80 a6 20 00 cmp %i0, 0
4001e6e4: 04 80 00 19 ble 4001e748 <rtems_rfs_file_close+0x224> <== ALWAYS TAKEN
4001e6e8: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001e6ec: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
4001e6f0: 7f ff d5 ed call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e6f4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e6f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e6fc: 02 80 00 13 be 4001e748 <rtems_rfs_file_close+0x224> <== NOT EXECUTED
4001e700: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001e704: 40 00 1a 68 call 400250a4 <strerror> <== NOT EXECUTED
4001e708: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e70c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001e710: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e714: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e718: 40 00 16 19 call 40023f7c <printf> <== NOT EXECUTED
4001e71c: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 40037ac8 <CSWTCH.2+0xed8><== NOT EXECUTED
}
free (handle);
4001e720: 7f ff a6 0a call 40007f48 <free> <== NOT EXECUTED
4001e724: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4001e728: 81 c7 e0 08 ret <== NOT EXECUTED
4001e72c: 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);
4001e730: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED
4001e734: 7f ff f7 41 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e738: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->dirty = false;
4001e73c: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001e740: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e744: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
4001e748: 7f ff a6 00 call 40007f48 <free>
4001e74c: 90 10 00 19 mov %i1, %o0
4001e750: 81 c7 e0 08 ret
4001e754: 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",
4001e758: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e75c: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
4001e760: 40 00 16 07 call 40023f7c <printf> <== NOT EXECUTED
4001e764: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
4001e768: 10 bf ff 78 b 4001e548 <rtems_rfs_file_close+0x24> <== NOT EXECUTED
4001e76c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
4001e770: 7f ff ea bb call 4001925c <_Chain_Extract> <== NOT EXECUTED
4001e774: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
if (rrc == 0)
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
4001e778: 7f ff a5 f4 call 40007f48 <free> <== NOT EXECUTED
4001e77c: 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);
4001e780: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e784: 7f ff f7 2d call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e788: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED
handle->dirty = false;
4001e78c: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001e790: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e794: 10 bf ff d6 b 4001e6ec <rtems_rfs_file_close+0x1c8> <== NOT EXECUTED
4001e798: 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",
4001e79c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001e7a0: 40 00 1a 41 call 400250a4 <strerror> <== NOT EXECUTED
4001e7a4: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001e7a8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001e7ac: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e7b0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001e7b4: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e7b8: 40 00 15 f1 call 40023f7c <printf> <== NOT EXECUTED
4001e7bc: 90 12 22 88 or %o0, 0x288, %o0 ! 40037a88 <CSWTCH.2+0xe98><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001e7c0: 10 bf ff bd b 4001e6b4 <rtems_rfs_file_close+0x190> <== NOT EXECUTED
4001e7c4: 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",
4001e7c8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001e7cc: 40 00 1a 36 call 400250a4 <strerror> <== NOT EXECUTED
4001e7d0: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001e7d4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001e7d8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e7dc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001e7e0: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e7e4: 40 00 15 e6 call 40023f7c <printf> <== NOT EXECUTED
4001e7e8: 90 12 22 48 or %o0, 0x248, %o0 ! 40037a48 <CSWTCH.2+0xe58><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001e7ec: 10 bf ff a3 b 4001e678 <rtems_rfs_file_close+0x154> <== NOT EXECUTED
4001e7f0: 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,
4001e7f4: c6 02 60 40 ld [ %o1 + 0x40 ], %g3
4001e7f8: 80 a0 80 03 cmp %g2, %g3
4001e7fc: 12 bf ff 8e bne 4001e634 <rtems_rfs_file_close+0x110> <== NEVER TAKEN
4001e800: 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);
4001e804: 10 bf ff 92 b 4001e64c <rtems_rfs_file_close+0x128>
4001e808: 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);
4001e80c: 7f ff ce d2 call 40012354 <rtems_rfs_inode_load>
4001e810: 90 10 00 1d mov %i5, %o0
4001e814: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
if (rrc == 0)
4001e818: 80 a2 20 00 cmp %o0, 0
4001e81c: 12 bf ff 8b bne 4001e648 <rtems_rfs_file_close+0x124> <== NEVER TAKEN
4001e820: b0 10 00 08 mov %o0, %i0
4001e824: 10 bf ff 55 b 4001e578 <rtems_rfs_file_close+0x54>
4001e828: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001f1d4 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001f1d4: 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 ));
4001f1d8: 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))
4001f1dc: 80 a0 40 08 cmp %g1, %o0
4001f1e0: 32 80 00 08 bne,a 4001f200 <rtems_rfs_file_get_shared+0x2c>
4001f1e4: 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;
4001f1e8: 81 c3 e0 08 retl
4001f1ec: 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))
4001f1f0: 80 a0 40 08 cmp %g1, %o0
4001f1f4: 22 80 00 08 be,a 4001f214 <rtems_rfs_file_get_shared+0x40><== ALWAYS TAKEN
4001f1f8: 90 10 20 00 clr %o0
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
4001f1fc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
4001f200: 80 a0 80 09 cmp %g2, %o1
4001f204: 32 bf ff fb bne,a 4001f1f0 <rtems_rfs_file_get_shared+0x1c>
4001f208: c2 00 40 00 ld [ %g1 ], %g1
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
4001f20c: 81 c3 e0 08 retl
4001f210: 90 10 00 01 mov %g1, %o0
4001f214: 81 c3 e0 08 retl
4001ea70 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
4001ea70: 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))
4001ea74: 90 10 20 20 mov 0x20, %o0
4001ea78: 92 10 20 00 clr %o1
4001ea7c: 7f ff d5 0a call 40013ea4 <rtems_rfs_trace>
4001ea80: ba 10 00 18 mov %i0, %i5
4001ea84: 80 8a 20 ff btst 0xff, %o0
4001ea88: 22 80 00 0c be,a 4001eab8 <rtems_rfs_file_io_end+0x48> <== ALWAYS TAKEN
4001ea8c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001ea90: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001ea94: 12 80 00 22 bne 4001eb1c <rtems_rfs_file_io_end+0xac> <== NOT EXECUTED
4001ea98: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
4001ea9c: 13 10 00 de sethi %hi(0x40037800), %o1 <== NOT EXECUTED
4001eaa0: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 40037af0 <CSWTCH.2+0xf00><== NOT EXECUTED
4001eaa4: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001eaa8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001eaac: 40 00 15 34 call 40023f7c <printf> <== NOT EXECUTED
4001eab0: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001eab4: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001eab8: 80 a0 60 00 cmp %g1, 0
4001eabc: 02 80 00 1a be 4001eb24 <rtems_rfs_file_io_end+0xb4> <== NEVER TAKEN
4001eac0: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
4001eac4: 12 80 00 8b bne 4001ecf0 <rtems_rfs_file_io_end+0x280>
4001eac8: 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),
4001eacc: 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));
4001ead0: 82 10 20 01 mov 1, %g1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ead4: 92 07 60 04 add %i5, 4, %o1
4001ead8: 7f ff f6 58 call 4001c438 <rtems_rfs_buffer_handle_release>
4001eadc: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001eae0: b0 92 20 00 orcc %o0, 0, %i0
4001eae4: 04 80 00 11 ble 4001eb28 <rtems_rfs_file_io_end+0xb8> <== ALWAYS TAKEN
4001eae8: 39 10 00 de sethi %hi(0x40037800), %i4
{
printf (
4001eaec: b8 17 22 f0 or %i4, 0x2f0, %i4 ! 40037af0 <CSWTCH.2+0xf00><== NOT EXECUTED
4001eaf0: 40 00 19 6d call 400250a4 <strerror> <== NOT EXECUTED
4001eaf4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001eaf8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001eafc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001eb00: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001eb04: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001eb08: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001eb0c: 40 00 15 1c call 40023f7c <printf> <== NOT EXECUTED
4001eb10: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED
"rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n",
read ? "read" : "write", size, rc, strerror (rc));
return rc;
4001eb14: 81 c7 e0 08 ret <== NOT EXECUTED
4001eb18: 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",
4001eb1c: 10 bf ff e2 b 4001eaa4 <rtems_rfs_file_io_end+0x34> <== NOT EXECUTED
4001eb20: 92 12 62 d0 or %o1, 0x2d0, %o1 <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
4001eb24: 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)))
4001eb28: 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;
4001eb2c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001eb30: 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;
4001eb34: b2 06 40 03 add %i1, %g3, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001eb38: 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 >=
4001eb3c: 80 a6 40 02 cmp %i1, %g2
4001eb40: 0a 80 00 07 bcs 4001eb5c <rtems_rfs_file_io_end+0xec>
4001eb44: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
4001eb48: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eb4c: 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++;
4001eb50: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eb54: 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++;
4001eb58: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
4001eb5c: 80 a6 a0 00 cmp %i2, 0
4001eb60: 32 80 00 11 bne,a 4001eba4 <rtems_rfs_file_io_end+0x134>
4001eb64: f2 07 40 00 ld [ %i5 ], %i1
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001eb68: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
}
length = false;
mtime = false;
if (!read &&
4001eb6c: 80 a0 a0 00 cmp %g2, 0
4001eb70: 02 80 00 05 be 4001eb84 <rtems_rfs_file_io_end+0x114>
4001eb74: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001eb78: 80 a0 e0 00 cmp %g3, 0
4001eb7c: 22 80 00 25 be,a 4001ec10 <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
4001eb80: c6 07 60 14 ld [ %i5 + 0x14 ], %g3 <== NOT EXECUTED
4001eb84: 80 a0 c0 02 cmp %g3, %g2
4001eb88: 28 80 00 22 bleu,a 4001ec10 <rtems_rfs_file_io_end+0x1a0>
4001eb8c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
4001eb90: 86 00 ff ff add %g3, -1, %g3
4001eb94: 80 a0 80 03 cmp %g2, %g3
4001eb98: 22 80 00 5f be,a 4001ed14 <rtems_rfs_file_io_end+0x2a4>
4001eb9c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001eba0: f2 07 40 00 ld [ %i5 ], %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001eba4: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001eba8: b2 0e 60 01 and %i1, 1, %i1
4001ebac: b2 1e 60 01 xor %i1, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
4001ebb0: b6 10 20 00 clr %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ebb4: 90 10 20 20 mov 0x20, %o0
4001ebb8: 92 10 20 00 clr %o1
4001ebbc: 7f ff d4 ba call 40013ea4 <rtems_rfs_trace>
4001ebc0: b2 0e 60 ff and %i1, 0xff, %i1
4001ebc4: 80 8a 20 ff btst 0xff, %o0
4001ebc8: 12 80 00 22 bne 4001ec50 <rtems_rfs_file_io_end+0x1e0> <== NEVER TAKEN
4001ebcc: 80 a0 00 19 cmp %g0, %i1
4001ebd0: 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)
4001ebd4: 80 a7 20 00 cmp %i4, 0
4001ebd8: 12 80 00 33 bne 4001eca4 <rtems_rfs_file_io_end+0x234>
4001ebdc: b6 0e e0 ff and %i3, 0xff, %i3
4001ebe0: 80 a6 60 00 cmp %i1, 0
4001ebe4: 12 80 00 30 bne 4001eca4 <rtems_rfs_file_io_end+0x234> <== ALWAYS TAKEN
4001ebe8: 80 a6 e0 00 cmp %i3, 0
if (read && atime)
handle->shared->atime = now;
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
4001ebec: 02 80 00 17 be 4001ec48 <rtems_rfs_file_io_end+0x1d8>
4001ebf0: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
4001ebf4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
4001ebf8: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
4001ebfc: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
4001ec00: c6 20 60 84 st %g3, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
4001ec04: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
4001ec08: 81 c7 e0 08 ret
4001ec0c: 81 e8 00 00 restore
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001ec10: 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;
4001ec14: c6 20 60 40 st %g3, [ %g1 + 0x40 ]
map->dirty = true;
4001ec18: 86 10 20 01 mov 1, %g3
4001ec1c: c6 28 60 34 stb %g3, [ %g1 + 0x34 ]
4001ec20: b2 08 a0 01 and %g2, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001ec24: b9 30 a0 01 srl %g2, 1, %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001ec28: b2 1e 60 01 xor %i1, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001ec2c: b8 1f 20 01 xor %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001ec30: b6 10 20 01 mov 1, %i3
4001ec34: 80 88 a0 04 btst 4, %g2
4001ec38: 02 bf ff df be 4001ebb4 <rtems_rfs_file_io_end+0x144> <== ALWAYS TAKEN
4001ec3c: b8 0f 20 01 and %i4, 1, %i4
4001ec40: 10 bf ff dd b 4001ebb4 <rtems_rfs_file_io_end+0x144> <== NOT EXECUTED
4001ec44: 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;
}
4001ec48: 81 c7 e0 08 ret
4001ec4c: 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",
4001ec50: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED
4001ec54: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
4001ec58: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
4001ec5c: 80 a0 00 1c cmp %g0, %i4 <== NOT EXECUTED
4001ec60: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
4001ec64: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
4001ec68: b6 0e e0 ff and %i3, 0xff, %i3 <== NOT EXECUTED
4001ec6c: 80 a0 00 1b cmp %g0, %i3 <== NOT EXECUTED
4001ec70: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
4001ec74: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
4001ec78: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
4001ec7c: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
4001ec80: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001ec84: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
4001ec88: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
4001ec8c: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
4001ec90: 40 00 14 bb call 40023f7c <printf> <== NOT EXECUTED
4001ec94: 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)
4001ec98: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4001ec9c: 02 bf ff d2 be 4001ebe4 <rtems_rfs_file_io_end+0x174> <== NOT EXECUTED
4001eca0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
{
time_t now = time (NULL);
4001eca4: 40 00 24 fa call 4002808c <time>
4001eca8: 90 10 20 00 clr %o0
if (read && atime)
4001ecac: 80 a6 60 00 cmp %i1, 0
4001ecb0: 02 80 00 06 be 4001ecc8 <rtems_rfs_file_io_end+0x258> <== NEVER TAKEN
4001ecb4: 80 a7 20 00 cmp %i4, 0
4001ecb8: 80 a6 a0 00 cmp %i2, 0
4001ecbc: 32 80 00 0b bne,a 4001ece8 <rtems_rfs_file_io_end+0x278>
4001ecc0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->shared->atime = now;
if (!read && mtime)
4001ecc4: 80 a7 20 00 cmp %i4, 0
4001ecc8: 02 bf ff c9 be 4001ebec <rtems_rfs_file_io_end+0x17c>
4001eccc: 80 a6 e0 00 cmp %i3, 0
4001ecd0: 80 a6 a0 01 cmp %i2, 1
4001ecd4: 02 bf ff c6 be 4001ebec <rtems_rfs_file_io_end+0x17c> <== NEVER TAKEN
4001ecd8: 80 a6 e0 00 cmp %i3, 0
handle->shared->mtime = now;
4001ecdc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001ece0: 10 bf ff c3 b 4001ebec <rtems_rfs_file_io_end+0x17c>
4001ece4: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
if (atime || mtime)
{
time_t now = time (NULL);
if (read && atime)
handle->shared->atime = now;
4001ece8: 10 bf ff f7 b 4001ecc4 <rtems_rfs_file_io_end+0x254>
4001ecec: 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),
4001ecf0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ecf4: 92 07 60 04 add %i5, 4, %o1
4001ecf8: 7f ff f5 d0 call 4001c438 <rtems_rfs_buffer_handle_release>
4001ecfc: 39 10 00 d8 sethi %hi(0x40036000), %i4
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001ed00: b0 92 20 00 orcc %o0, 0, %i0
4001ed04: 14 bf ff 7b bg 4001eaf0 <rtems_rfs_file_io_end+0x80> <== NEVER TAKEN
4001ed08: b8 17 22 d0 or %i4, 0x2d0, %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)))
4001ed0c: 10 bf ff 88 b 4001eb2c <rtems_rfs_file_io_end+0xbc>
4001ed10: 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),
4001ed14: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
4001ed18: 80 a0 c0 02 cmp %g3, %g2
4001ed1c: 28 bf ff a2 bleu,a 4001eba4 <rtems_rfs_file_io_end+0x134>
4001ed20: f2 07 40 00 ld [ %i5 ], %i1
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001ed24: 10 bf ff bc b 4001ec14 <rtems_rfs_file_io_end+0x1a4>
4001ed28: c4 07 40 00 ld [ %i5 ], %g2
4001ed2c <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))
4001ed2c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4001ed30: 80 a0 60 00 cmp %g1, 0
4001ed34: 02 80 00 07 be 4001ed50 <rtems_rfs_file_io_release+0x24> <== ALWAYS TAKEN
4001ed38: 92 02 20 04 add %o0, 4, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ed3c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
4001ed40: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001ed44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001ed48: 7f ff f5 bc call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ed4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
4001ed50: 81 c3 e0 08 retl
4001ed54: 90 10 20 00 clr %o0
4001e82c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
4001e82c: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e830: 90 10 20 20 mov 0x20, %o0
4001e834: 92 10 20 00 clr %o1
4001e838: 7f ff d5 9b call 40013ea4 <rtems_rfs_trace>
4001e83c: ba 10 00 18 mov %i0, %i5
4001e840: 80 8a 20 ff btst 0xff, %o0
4001e844: 22 80 00 0d be,a 4001e878 <rtems_rfs_file_io_start+0x4c> <== ALWAYS TAKEN
4001e848: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001e84c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001e850: 02 80 00 2f be 4001e90c <rtems_rfs_file_io_start+0xe0> <== NOT EXECUTED
4001e854: 13 10 00 de sethi %hi(0x40037800), %o1 <== NOT EXECUTED
4001e858: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
4001e85c: 92 12 62 d0 or %o1, 0x2d0, %o1 ! 400362d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001e860: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
4001e864: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
4001e868: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e86c: 40 00 15 c4 call 40023f7c <printf> <== NOT EXECUTED
4001e870: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 40037af8 <CSWTCH.2+0xf08><== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001e874: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001e878: 80 a0 60 00 cmp %g1, 0
4001e87c: 22 80 00 2c be,a 4001e92c <rtems_rfs_file_io_start+0x100>
4001e880: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
block, request_read);
if (rc > 0)
return rc;
}
if (read
4001e884: 80 a6 a0 00 cmp %i2, 0
4001e888: 02 80 00 0d be 4001e8bc <rtems_rfs_file_io_start+0x90>
4001e88c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001e890: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
4001e894: 80 a0 a0 00 cmp %g2, 0
4001e898: 12 80 00 1f bne 4001e914 <rtems_rfs_file_io_start+0xe8>
4001e89c: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
4001e8a0: 80 a0 e0 00 cmp %g3, 0
4001e8a4: 12 80 00 1d bne 4001e918 <rtems_rfs_file_io_start+0xec> <== ALWAYS TAKEN
4001e8a8: 86 00 ff ff add %g3, -1, %g3
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001e8ac: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
4001e8b0: 80 a7 20 00 cmp %i4, 0
4001e8b4: 32 80 00 05 bne,a 4001e8c8 <rtems_rfs_file_io_start+0x9c>
4001e8b8: 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));
4001e8bc: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
4001e8c0: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
4001e8c4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e8c8: 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);
4001e8cc: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e8d0: 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);
4001e8d4: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001e8d8: 7f ff d5 73 call 40013ea4 <rtems_rfs_trace>
4001e8dc: b0 10 20 00 clr %i0
4001e8e0: 80 8a 20 ff btst 0xff, %o0
4001e8e4: 32 80 00 04 bne,a 4001e8f4 <rtems_rfs_file_io_start+0xc8><== NEVER TAKEN
4001e8e8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
}
4001e8ec: 81 c7 e0 08 ret
4001e8f0: 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",
4001e8f4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001e8f8: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e8fc: 40 00 15 a0 call 40023f7c <printf> <== NOT EXECUTED
4001e900: 90 12 23 80 or %o0, 0x380, %o0 ! 40037b80 <CSWTCH.2+0xf90><== NOT EXECUTED
*available, size);
return 0;
}
4001e904: 81 c7 e0 08 ret <== NOT EXECUTED
4001e908: 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",
4001e90c: 10 bf ff d5 b 4001e860 <rtems_rfs_file_io_start+0x34> <== NOT EXECUTED
4001e910: 92 12 62 f0 or %o1, 0x2f0, %o1 <== NOT EXECUTED
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001e914: 86 00 ff ff add %g3, -1, %g3
4001e918: 80 a0 80 03 cmp %g2, %g3
4001e91c: 32 bf ff e9 bne,a 4001e8c0 <rtems_rfs_file_io_start+0x94>
4001e920: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001e924: 10 bf ff e3 b 4001e8b0 <rtems_rfs_file_io_start+0x84>
4001e928: 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),
4001e92c: 94 07 60 10 add %i5, 0x10, %o2
4001e930: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001e934: 96 07 bf fc add %fp, -4, %o3
4001e938: 7f ff f4 0b call 4001b964 <rtems_rfs_block_map_find>
4001e93c: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001e940: b0 92 20 00 orcc %o0, 0, %i0
4001e944: 04 80 00 0a ble 4001e96c <rtems_rfs_file_io_start+0x140>
4001e948: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
4001e94c: 32 bf ff e8 bne,a 4001e8ec <rtems_rfs_file_io_start+0xc0><== NEVER TAKEN
4001e950: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
4001e954: 80 a6 a0 00 cmp %i2, 0
4001e958: 22 80 00 2d be,a 4001ea0c <rtems_rfs_file_io_start+0x1e0><== ALWAYS TAKEN
4001e95c: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
4001e960: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
4001e964: 81 c7 e0 08 ret <== NOT EXECUTED
4001e968: 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 &&
4001e96c: 80 a6 a0 00 cmp %i2, 0
4001e970: 12 80 00 0d bne 4001e9a4 <rtems_rfs_file_io_start+0x178>
4001e974: 82 10 00 1a mov %i2, %g1
4001e978: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001e97c: 80 a0 a0 00 cmp %g2, 0
4001e980: 12 80 00 09 bne 4001e9a4 <rtems_rfs_file_io_start+0x178>
4001e984: 82 10 20 01 mov 1, %g1
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001e988: 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) ||
4001e98c: c6 06 40 00 ld [ %i1 ], %g3
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001e990: 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) ||
4001e994: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4001e998: 80 a0 c0 02 cmp %g3, %g2
4001e99c: 3a 80 00 02 bcc,a 4001e9a4 <rtems_rfs_file_io_start+0x178><== NEVER TAKEN
4001e9a0: 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))
4001e9a4: 90 10 20 20 mov 0x20, %o0
4001e9a8: 92 10 20 00 clr %o1
4001e9ac: 7f ff d5 3e call 40013ea4 <rtems_rfs_trace>
4001e9b0: b8 08 60 ff and %g1, 0xff, %i4
4001e9b4: 80 8a 20 ff btst 0xff, %o0
4001e9b8: 22 80 00 0b be,a 4001e9e4 <rtems_rfs_file_io_start+0x1b8><== ALWAYS TAKEN
4001e9bc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001e9c0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4001e9c4: 02 80 00 24 be 4001ea54 <rtems_rfs_file_io_start+0x228> <== NOT EXECUTED
4001e9c8: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
4001e9cc: 15 10 00 d7 sethi %hi(0x40035c00), %o2 <== NOT EXECUTED
4001e9d0: 94 12 a1 50 or %o2, 0x150, %o2 ! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
4001e9d4: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e9d8: 40 00 15 69 call 40023f7c <printf> <== NOT EXECUTED
4001e9dc: 90 12 23 48 or %o0, 0x348, %o0 ! 40037b48 <CSWTCH.2+0xf58><== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001e9e0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001e9e4: d4 07 bf fc ld [ %fp + -4 ], %o2
4001e9e8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001e9ec: 92 07 60 04 add %i5, 4, %o1
4001e9f0: 7f ff f7 0c call 4001c620 <rtems_rfs_buffer_handle_request>
4001e9f4: 96 10 00 1c mov %i4, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
4001e9f8: b0 92 20 00 orcc %o0, 0, %i0
4001e9fc: 04 bf ff a3 ble 4001e888 <rtems_rfs_file_io_start+0x5c> <== ALWAYS TAKEN
4001ea00: 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;
}
4001ea04: 81 c7 e0 08 ret <== NOT EXECUTED
4001ea08: 81 e8 00 00 restore <== NOT EXECUTED
{
*available = 0;
return 0;
}
if (rc != ENXIO)
4001ea0c: 12 bf ff b8 bne 4001e8ec <rtems_rfs_file_io_start+0xc0> <== NEVER TAKEN
4001ea10: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ea14: 7f ff d5 24 call 40013ea4 <rtems_rfs_trace>
4001ea18: 92 10 20 00 clr %o1
4001ea1c: 80 8a 20 ff btst 0xff, %o0
4001ea20: 12 80 00 10 bne 4001ea60 <rtems_rfs_file_io_start+0x234> <== NEVER TAKEN
4001ea24: 11 10 00 de sethi %hi(0x40037800), %o0
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001ea28: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001ea2c: 94 10 20 01 mov 1, %o2
4001ea30: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ea34: 96 07 bf fc add %fp, -4, %o3
4001ea38: 7f ff f4 4f call 4001bb74 <rtems_rfs_block_map_grow>
4001ea3c: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
4001ea40: b0 92 20 00 orcc %o0, 0, %i0
4001ea44: 14 bf ff aa bg 4001e8ec <rtems_rfs_file_io_start+0xc0>
4001ea48: 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))
4001ea4c: 10 bf ff d7 b 4001e9a8 <rtems_rfs_file_io_start+0x17c>
4001ea50: 90 10 20 20 mov 0x20, %o0
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001ea54: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED
4001ea58: 10 bf ff df b 4001e9d4 <rtems_rfs_file_io_start+0x1a8> <== NOT EXECUTED
4001ea5c: 94 12 a0 00 mov %o2, %o2 ! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
if (rc != ENXIO)
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
4001ea60: 40 00 15 df call 400241dc <puts> <== NOT EXECUTED
4001ea64: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001ea68: 10 bf ff f1 b 4001ea2c <rtems_rfs_file_io_start+0x200> <== NOT EXECUTED
4001ea6c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
4001e1e0 <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)
{
4001e1e0: 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))
4001e1e4: 90 10 20 08 mov 8, %o0
4001e1e8: 92 10 20 00 clr %o1
4001e1ec: 7f ff d7 2e call 40013ea4 <rtems_rfs_trace>
4001e1f0: a0 10 00 18 mov %i0, %l0
4001e1f4: 80 8a 20 ff btst 0xff, %o0
4001e1f8: 12 80 00 2b bne 4001e2a4 <rtems_rfs_file_open+0xc4> <== NEVER TAKEN
4001e1fc: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
4001e200: 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));
4001e204: 90 10 20 20 mov 0x20, %o0
4001e208: 7f ff a8 ed call 400085bc <malloc>
4001e20c: b0 10 20 0c mov 0xc, %i0
if (!handle)
4001e210: 80 a2 20 00 cmp %o0, 0
4001e214: 02 80 00 4f be 4001e350 <rtems_rfs_file_open+0x170> <== NEVER TAKEN
4001e218: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001e21c: fa 04 20 74 ld [ %l0 + 0x74 ], %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
4001e220: c0 22 00 00 clr [ %o0 ]
4001e224: c0 22 20 04 clr [ %o0 + 4 ]
4001e228: c0 22 20 10 clr [ %o0 + 0x10 ]
4001e22c: c0 22 20 14 clr [ %o0 + 0x14 ]
4001e230: c0 22 20 18 clr [ %o0 + 0x18 ]
4001e234: 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;
4001e238: 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 ));
4001e23c: 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))
4001e240: 80 a7 40 02 cmp %i5, %g2
4001e244: 12 80 00 06 bne 4001e25c <rtems_rfs_file_open+0x7c>
4001e248: c0 22 20 0c clr [ %o0 + 0xc ]
4001e24c: 30 80 00 1b b,a 4001e2b8 <rtems_rfs_file_open+0xd8>
4001e250: 80 a7 40 02 cmp %i5, %g2
4001e254: 02 80 00 19 be 4001e2b8 <rtems_rfs_file_open+0xd8> <== ALWAYS TAKEN
4001e258: 01 00 00 00 nop
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
4001e25c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001e260: 80 a6 40 01 cmp %i1, %g1
4001e264: 32 bf ff fb bne,a 4001e250 <rtems_rfs_file_open+0x70> <== ALWAYS TAKEN
4001e268: 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++;
4001e26c: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e270: 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++;
4001e274: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e278: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e27c: 7f ff d7 0a call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e280: c2 27 60 08 st %g1, [ %i5 + 8 ] <== NOT EXECUTED
4001e284: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e288: 12 80 00 34 bne 4001e358 <rtems_rfs_file_open+0x178> <== NOT EXECUTED
4001e28c: 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;
4001e290: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
4001e294: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
*file = handle;
4001e298: f8 26 c0 00 st %i4, [ %i3 ]
return 0;
4001e29c: 81 c7 e0 08 ret
4001e2a0: 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);
4001e2a4: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e2a8: 40 00 17 35 call 40023f7c <printf> <== NOT EXECUTED
4001e2ac: 90 12 21 38 or %o0, 0x138, %o0 ! 40037938 <CSWTCH.2+0xd48><== NOT EXECUTED
*file = NULL;
4001e2b0: 10 bf ff d5 b 4001e204 <rtems_rfs_file_open+0x24> <== NOT EXECUTED
4001e2b4: 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));
4001e2b8: 7f ff a8 c1 call 400085bc <malloc>
4001e2bc: 90 10 20 9c mov 0x9c, %o0
if (!shared)
4001e2c0: ba 92 20 00 orcc %o0, 0, %i5
4001e2c4: 02 80 00 46 be 4001e3dc <rtems_rfs_file_open+0x1fc> <== NEVER TAKEN
4001e2c8: 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));
4001e2cc: 40 00 16 ae call 40023d84 <memset>
4001e2d0: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4001e2d4: a2 07 60 0c add %i5, 0xc, %l1
4001e2d8: 90 10 00 10 mov %l0, %o0
4001e2dc: 92 10 00 19 mov %i1, %o1
4001e2e0: 94 10 00 11 mov %l1, %o2
4001e2e4: 7f ff d0 49 call 40012408 <rtems_rfs_inode_open>
4001e2e8: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001e2ec: b0 92 20 00 orcc %o0, 0, %i0
4001e2f0: 04 80 00 23 ble 4001e37c <rtems_rfs_file_open+0x19c> <== ALWAYS TAKEN
4001e2f4: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e2f8: 7f ff d6 eb call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e2fc: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e300: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e304: 02 80 00 09 be 4001e328 <rtems_rfs_file_open+0x148> <== NOT EXECUTED
4001e308: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
4001e30c: 40 00 1b 66 call 400250a4 <strerror> <== NOT EXECUTED
4001e310: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e314: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001e318: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e31c: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e320: 40 00 17 17 call 40023f7c <printf> <== NOT EXECUTED
4001e324: 90 12 21 80 or %o0, 0x180, %o0 ! 40037980 <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);
4001e328: 7f ff a7 08 call 40007f48 <free> <== NOT EXECUTED
4001e32c: 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);
4001e330: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001e334: 7f ff f8 41 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e338: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
4001e33c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e340: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001e344: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
4001e348: 7f ff a7 00 call 40007f48 <free> <== NOT EXECUTED
4001e34c: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return rc;
4001e350: 81 c7 e0 08 ret <== NOT EXECUTED
4001e354: 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);
4001e358: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
handle->flags = oflag;
handle->shared = shared;
*file = handle;
return 0;
4001e35c: 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);
4001e360: 40 00 17 07 call 40023f7c <printf> <== NOT EXECUTED
4001e364: 90 12 21 58 or %o0, 0x158, %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;
4001e368: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
4001e36c: fa 27 20 1c st %i5, [ %i4 + 0x1c ] <== NOT EXECUTED
*file = handle;
4001e370: f8 26 c0 00 st %i4, [ %i3 ] <== NOT EXECUTED
return 0;
4001e374: 81 c7 e0 08 ret <== NOT EXECUTED
4001e378: 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);
4001e37c: 90 10 00 10 mov %l0, %o0
4001e380: 92 10 00 11 mov %l1, %o1
4001e384: 7f ff f4 a3 call 4001b610 <rtems_rfs_block_map_open>
4001e388: 94 07 60 34 add %i5, 0x34, %o2
if (rc > 0)
4001e38c: b0 92 20 00 orcc %o0, 0, %i0
4001e390: 24 80 00 1e ble,a 4001e408 <rtems_rfs_file_open+0x228> <== ALWAYS TAKEN
4001e394: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e398: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
4001e39c: 7f ff d6 c2 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001e3a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001e3a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e3a8: 22 80 00 0a be,a 4001e3d0 <rtems_rfs_file_open+0x1f0> <== NOT EXECUTED
4001e3ac: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001e3b0: 40 00 1b 3d call 400250a4 <strerror> <== NOT EXECUTED
4001e3b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e3b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001e3bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e3c0: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e3c4: 40 00 16 ee call 40023f7c <printf> <== NOT EXECUTED
4001e3c8: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400379b8 <CSWTCH.2+0xdc8><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
4001e3cc: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001e3d0: 7f ff d0 86 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001e3d4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001e3d8: 30 bf ff d4 b,a 4001e328 <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);
4001e3dc: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
4001e3e0: 7f ff f8 16 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e3e4: 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;
4001e3e8: 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);
4001e3ec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e3f0: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001e3f4: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
4001e3f8: 7f ff a6 d4 call 40007f48 <free> <== NOT EXECUTED
4001e3fc: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return ENOMEM;
4001e400: 81 c7 e0 08 ret <== NOT EXECUTED
4001e404: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
4001e408: 84 10 20 01 mov 1, %g2
4001e40c: 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);
4001e410: f0 08 60 0c ldub [ %g1 + 0xc ], %i0
4001e414: c8 08 60 0d ldub [ %g1 + 0xd ], %g4
4001e418: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
4001e41c: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
4001e420: b1 2e 20 18 sll %i0, 0x18, %i0
4001e424: 89 29 20 10 sll %g4, 0x10, %g4
4001e428: 85 28 a0 08 sll %g2, 8, %g2
4001e42c: 88 16 00 04 or %i0, %g4, %g4
4001e430: 86 11 00 03 or %g4, %g3, %g3
4001e434: 84 10 c0 02 or %g3, %g2, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001e438: c4 27 60 84 st %g2, [ %i5 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001e43c: 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);
4001e440: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001e444: 90 04 20 74 add %l0, 0x74, %o0
4001e448: 85 28 a0 08 sll %g2, 8, %g2
4001e44c: 84 10 c0 02 or %g3, %g2, %g2
4001e450: 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);
4001e454: f0 08 60 10 ldub [ %g1 + 0x10 ], %i0
4001e458: c8 08 60 11 ldub [ %g1 + 0x11 ], %g4
4001e45c: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
4001e460: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
4001e464: b1 2e 20 18 sll %i0, 0x18, %i0
4001e468: 89 29 20 10 sll %g4, 0x10, %g4
4001e46c: 85 28 a0 08 sll %g2, 8, %g2
4001e470: 88 16 00 04 or %i0, %g4, %g4
4001e474: 86 11 00 03 or %g4, %g3, %g3
4001e478: 84 10 c0 02 or %g3, %g2, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001e47c: 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);
4001e480: f0 08 60 14 ldub [ %g1 + 0x14 ], %i0
4001e484: c8 08 60 15 ldub [ %g1 + 0x15 ], %g4
4001e488: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
4001e48c: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
4001e490: b1 2e 20 18 sll %i0, 0x18, %i0
4001e494: 89 29 20 10 sll %g4, 0x10, %g4
4001e498: 85 28 a0 08 sll %g2, 8, %g2
4001e49c: 88 16 00 04 or %i0, %g4, %g4
4001e4a0: 86 11 00 03 or %g4, %g3, %g3
4001e4a4: 84 10 c0 02 or %g3, %g2, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
4001e4a8: 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);
4001e4ac: c8 08 60 18 ldub [ %g1 + 0x18 ], %g4
4001e4b0: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
4001e4b4: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
4001e4b8: c2 08 60 1a ldub [ %g1 + 0x1a ], %g1
4001e4bc: 89 29 20 18 sll %g4, 0x18, %g4
4001e4c0: 87 28 e0 10 sll %g3, 0x10, %g3
4001e4c4: 83 28 60 08 sll %g1, 8, %g1
4001e4c8: 86 11 00 03 or %g4, %g3, %g3
4001e4cc: 84 10 c0 02 or %g3, %g2, %g2
4001e4d0: 82 10 80 01 or %g2, %g1, %g1
4001e4d4: 92 10 00 1d mov %i5, %o1
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
4001e4d8: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
4001e4dc: 7f ff bc d4 call 4000d82c <_Chain_Append>
4001e4e0: 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);
4001e4e4: 92 10 00 11 mov %l1, %o1
4001e4e8: 94 10 20 00 clr %o2
4001e4ec: 7f ff cf fe call 400124e4 <rtems_rfs_inode_unload>
4001e4f0: 90 10 00 10 mov %l0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001e4f4: 90 10 20 08 mov 8, %o0
4001e4f8: 7f ff d6 6b call 40013ea4 <rtems_rfs_trace>
4001e4fc: 92 10 20 00 clr %o1
4001e500: 80 8a 20 ff btst 0xff, %o0
4001e504: 22 bf ff 64 be,a 4001e294 <rtems_rfs_file_open+0xb4> <== ALWAYS TAKEN
4001e508: f4 27 00 00 st %i2, [ %i4 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001e50c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001e510: 11 10 00 de sethi %hi(0x40037800), %o0 <== NOT EXECUTED
4001e514: 40 00 16 9a call 40023f7c <printf> <== NOT EXECUTED
4001e518: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400379f0 <CSWTCH.2+0xe00><== NOT EXECUTED
}
handle->flags = oflag;
4001e51c: 10 bf ff 5e b 4001e294 <rtems_rfs_file_open+0xb4> <== NOT EXECUTED
4001e520: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
4001ed58 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
4001ed58: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ed5c: 90 10 20 20 mov 0x20, %o0
4001ed60: 92 10 20 00 clr %o1
4001ed64: 7f ff d4 50 call 40013ea4 <rtems_rfs_trace>
4001ed68: ba 10 00 18 mov %i0, %i5
4001ed6c: 80 8a 20 ff btst 0xff, %o0
4001ed70: 32 80 00 2b bne,a 4001ee1c <rtems_rfs_file_seek+0xc4> <== NEVER TAKEN
4001ed74: 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),
4001ed78: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001ed7c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ed80: 7f ff f2 0e call 4001b5b8 <rtems_rfs_block_get_size>
4001ed84: 92 02 60 84 add %o1, 0x84, %o1
4001ed88: 80 a6 40 08 cmp %i1, %o0
4001ed8c: 18 80 00 1b bgu 4001edf8 <rtems_rfs_file_seek+0xa0> <== NEVER TAKEN
4001ed90: 01 00 00 00 nop
4001ed94: 02 80 00 17 be 4001edf0 <rtems_rfs_file_seek+0x98> <== ALWAYS TAKEN
4001ed98: 80 a6 80 09 cmp %i2, %o1
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
4001ed9c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001eda0: b8 07 60 10 add %i5, 0x10, %i4
4001eda4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001eda8: 92 10 00 19 mov %i1, %o1
4001edac: 94 10 00 1a mov %i2, %o2
4001edb0: 7f ff f1 d3 call 4001b4fc <rtems_rfs_block_get_bpos>
4001edb4: 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))
4001edb8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001edbc: 80 a0 60 00 cmp %g1, 0
4001edc0: 02 80 00 13 be 4001ee0c <rtems_rfs_file_seek+0xb4>
4001edc4: 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),
4001edc8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001edcc: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001edd0: 96 07 bf fc add %fp, -4, %o3
4001edd4: 7f ff f2 e4 call 4001b964 <rtems_rfs_block_map_find>
4001edd8: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001eddc: b0 92 20 00 orcc %o0, 0, %i0
4001ede0: 24 80 00 15 ble,a 4001ee34 <rtems_rfs_file_seek+0xdc> <== ALWAYS TAKEN
4001ede4: c4 07 60 08 ld [ %i5 + 8 ], %g2
return rc;
}
*new_pos = pos;
return 0;
}
4001ede8: 81 c7 e0 08 ret <== NOT EXECUTED
4001edec: 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),
4001edf0: 28 bf ff ec bleu,a 4001eda0 <rtems_rfs_file_seek+0x48>
4001edf4: 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);
4001edf8: 7f ff ff cd call 4001ed2c <rtems_rfs_file_io_release>
4001edfc: 90 10 00 1d mov %i5, %o0
if (rc > 0)
4001ee00: b0 92 20 00 orcc %o0, 0, %i0
4001ee04: 14 80 00 16 bg 4001ee5c <rtems_rfs_file_seek+0x104> <== NEVER TAKEN
4001ee08: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
4001ee0c: f2 26 c0 00 st %i1, [ %i3 ]
4001ee10: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
}
4001ee14: 81 c7 e0 08 ret
4001ee18: 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);
4001ee1c: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001ee20: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001ee24: 40 00 14 56 call 40023f7c <printf> <== NOT EXECUTED
4001ee28: 90 12 20 58 or %o0, 0x58, %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),
4001ee2c: 10 bf ff d4 b 4001ed7c <rtems_rfs_file_seek+0x24> <== NOT EXECUTED
4001ee30: 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)
4001ee34: c2 07 bf fc ld [ %fp + -4 ], %g1
4001ee38: 80 a0 80 01 cmp %g2, %g1
4001ee3c: 02 bf ff f4 be 4001ee0c <rtems_rfs_file_seek+0xb4> <== ALWAYS TAKEN
4001ee40: 92 07 60 04 add %i5, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ee44: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001ee48: 7f ff f5 7c call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ee4c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001ee50: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001ee54: 24 bf ff ef ble,a 4001ee10 <rtems_rfs_file_seek+0xb8> <== NOT EXECUTED
4001ee58: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED
return rc;
}
*new_pos = pos;
return 0;
}
4001ee5c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ee60: 81 e8 00 00 restore <== NOT EXECUTED
4001ee64 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4001ee64: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
4001ee68: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ee6c: 90 10 20 20 mov 0x20, %o0
4001ee70: 92 10 20 00 clr %o1
4001ee74: 7f ff d4 0c call 40013ea4 <rtems_rfs_trace>
4001ee78: b8 10 00 19 mov %i1, %i4
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4001ee7c: 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))
4001ee80: 80 8a 20 ff btst 0xff, %o0
4001ee84: 12 80 00 92 bne 4001f0cc <rtems_rfs_file_set_size+0x268> <== NEVER TAKEN
4001ee88: 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);
4001ee8c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
4001ee90: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ee94: 7f ff f1 c9 call 4001b5b8 <rtems_rfs_block_get_size>
4001ee98: 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)
4001ee9c: 80 a7 00 08 cmp %i4, %o0
4001eea0: 02 80 00 98 be 4001f100 <rtems_rfs_file_set_size+0x29c> <== ALWAYS TAKEN
4001eea4: 80 a7 40 09 cmp %i5, %o1
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
4001eea8: 80 97 00 1d orcc %i4, %i5, %g0 <== NOT EXECUTED
4001eeac: 22 80 00 9a be,a 4001f114 <rtems_rfs_file_set_size+0x2b0><== NOT EXECUTED
4001eeb0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
4001eeb4: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
4001eeb8: 08 80 00 57 bleu 4001f014 <rtems_rfs_file_set_size+0x1b0> <== ALWAYS TAKEN
4001eebc: 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));
4001eec0: e8 06 20 1c ld [ %i0 + 0x1c ], %l4 <== NOT EXECUTED
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
4001eec4: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eec8: c2 05 20 98 ld [ %l4 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
4001eecc: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eed0: a6 10 00 14 mov %l4, %l3
4001eed4: f4 00 60 08 ld [ %g1 + 8 ], %i2
read_block = false;
while (count)
4001eed8: a4 10 20 00 clr %l2
4001eedc: a2 10 20 01 mov 1, %l1
4001eee0: 80 97 00 1d orcc %i4, %i5, %g0
4001eee4: 12 80 00 2a bne 4001ef8c <rtems_rfs_file_set_size+0x128> <== ALWAYS TAKEN
4001eee8: a0 06 20 04 add %i0, 4, %l0
4001eeec: 10 80 00 92 b 4001f134 <rtems_rfs_file_set_size+0x2d0> <== NOT EXECUTED
4001eef0: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2 <== NOT EXECUTED
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
4001eef4: 80 a0 80 1d cmp %g2, %i5
4001eef8: 28 80 00 45 bleu,a 4001f00c <rtems_rfs_file_set_size+0x1a8>
4001eefc: c0 26 e0 40 clr [ %i3 + 0x40 ]
{
length = count + bpos.boff;
4001ef00: b4 00 40 1d add %g1, %i5, %i2
4001ef04: 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;
4001ef08: f4 26 e0 40 st %i2, [ %i3 + 0x40 ]
read_block = true;
4001ef0c: 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),
4001ef10: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001ef14: d4 07 bf f0 ld [ %fp + -16 ], %o2
4001ef18: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ef1c: 92 10 00 10 mov %l0, %o1
4001ef20: 7f ff f5 c0 call 4001c620 <rtems_rfs_buffer_handle_request>
4001ef24: 96 0c a0 01 and %l2, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
4001ef28: 82 92 20 00 orcc %o0, 0, %g1
4001ef2c: 14 80 00 66 bg 4001f0c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
4001ef30: 92 10 20 00 clr %o1
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
4001ef34: c4 06 20 0c ld [ %i0 + 0xc ], %g2
memset (dst + bpos.boff, 0, length - bpos.boff);
4001ef38: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001ef3c: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
4001ef40: 94 26 80 01 sub %i2, %g1, %o2
4001ef44: 40 00 13 90 call 40023d84 <memset>
4001ef48: 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),
4001ef4c: 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));
4001ef50: e2 2e 20 04 stb %l1, [ %i0 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ef54: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ef58: 7f ff f5 38 call 4001c438 <rtems_rfs_buffer_handle_release>
4001ef5c: 92 10 00 10 mov %l0, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001ef60: 82 92 20 00 orcc %o0, 0, %g1
4001ef64: 14 80 00 58 bg 4001f0c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
4001ef68: 01 00 00 00 nop
return rc;
count -= length - bpos.boff;
4001ef6c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001ef70: 82 26 80 01 sub %i2, %g1, %g1
4001ef74: ba a7 40 01 subcc %i5, %g1, %i5
4001ef78: 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)
4001ef7c: 80 97 00 1d orcc %i4, %i5, %g0
4001ef80: 22 80 00 6c be,a 4001f130 <rtems_rfs_file_set_size+0x2cc>
4001ef84: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
4001ef88: 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);
4001ef8c: c2 06 e0 40 ld [ %i3 + 0x40 ], %g1
4001ef90: c4 06 e0 3c ld [ %i3 + 0x3c ], %g2
4001ef94: c2 27 bf f8 st %g1, [ %fp + -8 ]
4001ef98: c4 27 bf f4 st %g2, [ %fp + -12 ]
4001ef9c: 80 a0 60 00 cmp %g1, 0
4001efa0: 02 80 00 04 be 4001efb0 <rtems_rfs_file_set_size+0x14c>
4001efa4: c0 27 bf fc clr [ %fp + -4 ]
4001efa8: 84 00 bf ff add %g2, -1, %g2
4001efac: c4 27 bf f4 st %g2, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001efb0: d0 04 e0 98 ld [ %l3 + 0x98 ], %o0
4001efb4: 92 10 00 19 mov %i1, %o1
4001efb8: 94 07 bf f4 add %fp, -12, %o2
4001efbc: 7f ff f2 6a call 4001b964 <rtems_rfs_block_map_find>
4001efc0: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
4001efc4: 82 92 20 00 orcc %o0, 0, %g1
4001efc8: 04 80 00 0c ble 4001eff8 <rtems_rfs_file_set_size+0x194>
4001efcc: 80 a0 60 06 cmp %g1, 6
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
4001efd0: 12 80 00 3d bne 4001f0c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
4001efd4: 92 10 00 19 mov %i1, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001efd8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001efdc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001efe0: 94 10 20 01 mov 1, %o2
4001efe4: 7f ff f2 e4 call 4001bb74 <rtems_rfs_block_map_grow>
4001efe8: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
4001efec: 82 92 20 00 orcc %o0, 0, %g1
4001eff0: 14 80 00 35 bg 4001f0c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
4001eff4: 01 00 00 00 nop
return rc;
}
if (count < (length - bpos.boff))
4001eff8: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001effc: 80 a7 20 00 cmp %i4, 0
4001f000: 02 bf ff bd be 4001eef4 <rtems_rfs_file_set_size+0x90> <== ALWAYS TAKEN
4001f004: 84 26 80 01 sub %i2, %g1, %g2
4001f008: c0 26 e0 40 clr [ %i3 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001f00c: 10 bf ff c1 b 4001ef10 <rtems_rfs_file_set_size+0xac>
4001f010: e2 2e e0 34 stb %l1, [ %i3 + 0x34 ]
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
4001f014: 02 80 00 54 be 4001f164 <rtems_rfs_file_set_size+0x300> <== ALWAYS TAKEN
4001f018: 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);
4001f01c: 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) -
4001f020: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
4001f024: 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) /
4001f028: 92 87 7f ff addcc %i5, -1, %o1
4001f02c: f2 04 20 08 ld [ %l0 + 8 ], %i1
4001f030: 90 47 3f ff addx %i4, -1, %o0
4001f034: 96 10 00 19 mov %i1, %o3
4001f038: 40 00 48 24 call 400310c8 <__udivdi3>
4001f03c: 94 10 20 00 clr %o2
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4001f040: 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));
4001f044: 96 10 00 19 mov %i1, %o3
4001f048: 94 10 20 00 clr %o2
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4001f04c: 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));
4001f050: 90 10 00 1c mov %i4, %o0
4001f054: 40 00 48 f1 call 40031418 <__umoddi3>
4001f058: 92 10 00 1d mov %i5, %o1
if (blocks)
4001f05c: 80 a6 60 00 cmp %i1, 0
4001f060: 12 80 00 4e bne 4001f198 <rtems_rfs_file_set_size+0x334>
4001f064: 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),
4001f068: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001f06c: 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;
4001f070: fa 26 e0 40 st %i5, [ %i3 + 0x40 ]
4001f074: 80 a0 60 00 cmp %g1, 0
4001f078: 02 80 00 3f be 4001f174 <rtems_rfs_file_set_size+0x310>
4001f07c: c4 2e e0 34 stb %g2, [ %i3 + 0x34 ]
4001f080: 80 a6 a0 00 cmp %i2, 0
4001f084: 12 80 00 3d bne 4001f178 <rtems_rfs_file_set_size+0x314> <== ALWAYS TAKEN
4001f088: 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),
4001f08c: f4 26 20 10 st %i2, [ %i0 + 0x10 ] <== NOT EXECUTED
4001f090: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
4001f094: 80 a7 60 00 cmp %i5, 0
4001f098: 02 80 00 3e be 4001f190 <rtems_rfs_file_set_size+0x32c> <== NEVER TAKEN
4001f09c: c0 26 20 18 clr [ %i0 + 0x18 ]
4001f0a0: 82 06 bf ff add %i2, -1, %g1
4001f0a4: a8 10 00 13 mov %l3, %l4
4001f0a8: 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))
4001f0ac: 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);
4001f0b0: 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))
4001f0b4: 80 88 60 02 btst 2, %g1
4001f0b8: 02 80 00 25 be 4001f14c <rtems_rfs_file_set_size+0x2e8> <== ALWAYS TAKEN
4001f0bc: fa 25 20 88 st %i5, [ %l4 + 0x88 ]
handle->shared->mtime = time (NULL);
}
return 0;
4001f0c0: 82 10 20 00 clr %g1
}
4001f0c4: 81 c7 e0 08 ret
4001f0c8: 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);
4001f0cc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001f0d0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001f0d4: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f0d8: 40 00 13 a9 call 40023f7c <printf> <== NOT EXECUTED
4001f0dc: 90 12 20 78 or %o0, 0x78, %o0 ! 40037c78 <CSWTCH.2+0x1088><== NOT EXECUTED
size = rtems_rfs_file_size (handle);
4001f0e0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
4001f0e4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
4001f0e8: 7f ff f1 34 call 4001b5b8 <rtems_rfs_block_get_size> <== NOT EXECUTED
4001f0ec: 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)
4001f0f0: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
4001f0f4: 12 bf ff 6e bne 4001eeac <rtems_rfs_file_set_size+0x48> <== NOT EXECUTED
4001f0f8: 80 97 00 1d orcc %i4, %i5, %g0 <== NOT EXECUTED
4001f0fc: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
4001f100: 02 bf ff f0 be 4001f0c0 <rtems_rfs_file_set_size+0x25c>
4001f104: 80 97 00 1d orcc %i4, %i5, %g0
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
4001f108: 12 bf ff 6c bne 4001eeb8 <rtems_rfs_file_set_size+0x54>
4001f10c: 80 a7 00 08 cmp %i4, %o0
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001f110: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001f114: 92 10 00 19 mov %i1, %o1
4001f118: 7f ff f4 55 call 4001c26c <rtems_rfs_block_map_free_all>
4001f11c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (rc > 0)
4001f120: 82 92 20 00 orcc %o0, 0, %g1
4001f124: 14 bf ff e8 bg 4001f0c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
4001f128: 01 00 00 00 nop
4001f12c: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
4001f130: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
4001f134: 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))
4001f138: 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);
4001f13c: 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))
4001f140: 80 88 60 02 btst 2, %g1
4001f144: 12 bf ff df bne 4001f0c0 <rtems_rfs_file_set_size+0x25c> <== NEVER TAKEN
4001f148: fa 25 20 88 st %i5, [ %l4 + 0x88 ]
handle->shared->mtime = time (NULL);
4001f14c: 40 00 23 d0 call 4002808c <time>
4001f150: 90 10 20 00 clr %o0
}
return 0;
4001f154: 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);
4001f158: d0 25 20 90 st %o0, [ %l4 + 0x90 ]
}
return 0;
}
4001f15c: 81 c7 e0 08 ret
4001f160: 91 e8 00 01 restore %g0, %g1, %o0
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
4001f164: 28 bf ff af bleu,a 4001f020 <rtems_rfs_file_set_size+0x1bc>
4001f168: 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));
4001f16c: 10 bf ff 56 b 4001eec4 <rtems_rfs_file_set_size+0x60>
4001f170: 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),
4001f174: 80 a0 40 1a cmp %g1, %i2
4001f178: 3a bf ff c6 bcc,a 4001f090 <rtems_rfs_file_set_size+0x22c><== NEVER TAKEN
4001f17c: f4 26 20 10 st %i2, [ %i0 + 0x10 ] <== NOT EXECUTED
4001f180: 84 06 bf ff add %i2, -1, %g2
4001f184: 80 a0 40 02 cmp %g1, %g2
4001f188: 22 80 00 0e be,a 4001f1c0 <rtems_rfs_file_set_size+0x35c><== ALWAYS TAKEN
4001f18c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001f190: 10 bf ff c7 b 4001f0ac <rtems_rfs_file_set_size+0x248> <== NOT EXECUTED
4001f194: 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),
4001f198: 90 10 00 10 mov %l0, %o0
4001f19c: 92 04 e0 34 add %l3, 0x34, %o1
4001f1a0: 7f ff f3 6b call 4001bf4c <rtems_rfs_block_map_shrink>
4001f1a4: 94 10 00 19 mov %i1, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
4001f1a8: 82 92 20 00 orcc %o0, 0, %g1
4001f1ac: 14 bf ff c6 bg 4001f0c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
4001f1b0: 01 00 00 00 nop
4001f1b4: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
4001f1b8: 10 bf ff ac b 4001f068 <rtems_rfs_file_set_size+0x204>
4001f1bc: 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),
4001f1c0: 80 a7 40 01 cmp %i5, %g1
4001f1c4: 2a bf ff b3 bcs,a 4001f090 <rtems_rfs_file_set_size+0x22c>
4001f1c8: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
4001f1cc: 10 bf ff b8 b 4001f0ac <rtems_rfs_file_set_size+0x248>
4001f1d0: a8 10 00 13 mov %l3, %l4
40010c78 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
40010c78: 9d e3 be c8 save %sp, -312, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
40010c7c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40010c80: 80 a0 60 00 cmp %g1, 0
40010c84: 32 80 00 88 bne,a 40010ea4 <rtems_rfs_format+0x22c> <== NEVER TAKEN
40010c88: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40010c8c: 92 10 20 00 clr %o1
40010c90: 94 10 20 84 mov 0x84, %o2
40010c94: 40 00 4c 3c call 40023d84 <memset>
40010c98: 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;
40010c9c: 82 07 bf c4 add %fp, -60, %g1
40010ca0: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
40010ca4: 82 07 bf c0 add %fp, -64, %g1
40010ca8: 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;
40010cac: 82 07 bf d4 add %fp, -44, %g1
40010cb0: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
40010cb4: 82 07 bf d0 add %fp, -48, %g1
40010cb8: 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;
40010cbc: 82 07 bf e4 add %fp, -28, %g1
40010cc0: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
40010cc4: 82 07 bf e0 add %fp, -32, %g1
40010cc8: 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;
40010ccc: 82 07 bf f4 add %fp, -12, %g1
40010cd0: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
40010cd4: 82 07 bf f0 add %fp, -16, %g1
40010cd8: 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;
40010cdc: 82 10 20 05 mov 5, %g1
40010ce0: 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;
40010ce4: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40010ce8: 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;
40010cec: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40010cf0: 40 00 2f 04 call 4001c900 <rtems_rfs_buffer_open>
40010cf4: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
40010cf8: ba 92 20 00 orcc %o0, 0, %i5
40010cfc: 14 80 02 bd bg 400117f0 <rtems_rfs_format+0xb78> <== NEVER TAKEN
40010d00: c2 07 bf 8c ld [ %fp + -116 ], %g1
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40010d04: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
40010d08: 80 a7 20 00 cmp %i4, 0
40010d0c: 02 80 02 c2 be 40011814 <rtems_rfs_format+0xb9c> <== NEVER TAKEN
40010d10: 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;
40010d14: fa 06 40 00 ld [ %i1 ], %i5
if (!fs->block_size)
40010d18: 80 a7 60 00 cmp %i5, 0
40010d1c: 02 80 00 d1 be 40011060 <rtems_rfs_format+0x3e8>
40010d20: 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)
40010d24: 90 10 00 1d mov %i5, %o0
40010d28: 40 00 7e 2b call 400305d4 <.urem>
40010d2c: 92 10 00 1c mov %i4, %o1
40010d30: 80 a2 20 00 cmp %o0, 0
40010d34: 32 80 00 ef bne,a 400110f0 <rtems_rfs_format+0x478> <== NEVER TAKEN
40010d38: 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;
40010d3c: 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);
40010d40: 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)
40010d44: 80 a0 60 00 cmp %g1, 0
40010d48: 12 80 00 50 bne 40010e88 <rtems_rfs_format+0x210> <== NEVER TAKEN
40010d4c: 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);
40010d50: 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;
40010d54: 40 00 39 3b call 4001f240 <rtems_rfs_fs_media_size>
40010d58: 90 07 bf 7c add %fp, -132, %o0
40010d5c: fa 07 bf 84 ld [ %fp + -124 ], %i5
40010d60: 94 10 20 00 clr %o2
40010d64: 40 00 80 d9 call 400310c8 <__udivdi3>
40010d68: 96 10 00 1d mov %i5, %o3
40010d6c: d2 27 bf 80 st %o1, [ %fp + -128 ]
40010d70: 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));
40010d74: 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)
40010d78: 80 a2 60 00 cmp %o1, 0
40010d7c: 02 80 00 06 be 40010d94 <rtems_rfs_format+0x11c> <== NEVER TAKEN
40010d80: a0 10 20 01 mov 1, %l0
return 1;
return ((dividend - 1) / divisor) + 1;
40010d84: 90 02 7f ff add %o1, -1, %o0
40010d88: 7f ff c6 46 call 400026a0 <.udiv>
40010d8c: 92 10 00 1a mov %i2, %o1
40010d90: 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;
40010d94: f6 06 60 08 ld [ %i1 + 8 ], %i3
if (!fs->group_inodes)
40010d98: 80 a6 e0 00 cmp %i3, 0
40010d9c: 02 80 01 38 be 4001127c <rtems_rfs_format+0x604> <== ALWAYS TAKEN
40010da0: e0 27 bf a0 st %l0, [ %fp + -96 ]
40010da4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40010da8: 7f ff c6 3e call 400026a0 <.udiv> <== NOT EXECUTED
40010dac: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
40010db0: 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;
40010db4: 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;
40010db8: 90 06 ff ff add %i3, -1, %o0 <== NOT EXECUTED
40010dbc: 7f ff c6 39 call 400026a0 <.udiv>
40010dc0: 92 10 00 1c mov %i4, %o1
40010dc4: 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;
40010dc8: 7f ff c5 fc call 400025b8 <.umul>
40010dcc: 92 10 00 1c mov %i4, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40010dd0: 80 a6 80 08 cmp %i2, %o0
40010dd4: 0a 80 01 25 bcs 40011268 <rtems_rfs_format+0x5f0> <== NEVER TAKEN
40010dd8: 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)
40010ddc: 80 a0 60 00 cmp %g1, 0
40010de0: 12 80 01 25 bne 40011274 <rtems_rfs_format+0x5fc> <== NEVER TAKEN
40010de4: d0 27 bf a8 st %o0, [ %fp + -88 ]
{
fs->max_name_length = 512;
40010de8: 82 10 22 00 mov 0x200, %g1
40010dec: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
40010df0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40010df4: 80 a0 60 00 cmp %g1, 0
40010df8: 12 80 00 c5 bne 4001110c <rtems_rfs_format+0x494> <== NEVER TAKEN
40010dfc: 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));
40010e00: 92 10 00 1d mov %i5, %o1
40010e04: 40 00 2f 72 call 4001cbcc <rtems_rfs_buffer_setblksize>
40010e08: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
40010e0c: ba 92 20 00 orcc %o0, 0, %i5
40010e10: 14 80 02 33 bg 400116dc <rtems_rfs_format+0xa64> <== NEVER TAKEN
40010e14: 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;
40010e18: c0 2f bf 30 clrb [ %fp + -208 ]
handle->bnum = 0;
40010e1c: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
40010e20: 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);
40010e24: 90 07 bf 7c add %fp, -132, %o0
40010e28: 94 10 20 00 clr %o2
40010e2c: 40 00 2d fd call 4001c620 <rtems_rfs_buffer_handle_request>
40010e30: 96 10 20 00 clr %o3
if (rc > 0)
40010e34: ba 92 20 00 orcc %o0, 0, %i5
40010e38: 04 80 00 20 ble 40010eb8 <rtems_rfs_format+0x240> <== ALWAYS TAKEN
40010e3c: 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);
40010e40: 40 00 2d 7e call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40010e44: 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",
40010e48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40010e4c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40010e50: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
40010e54: 40 00 50 94 call 400250a4 <strerror> <== NOT EXECUTED
40010e58: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40010e5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40010e60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40010e64: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40010e68: 40 00 4c 45 call 40023f7c <printf> <== NOT EXECUTED
40010e6c: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 400355f0 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
40010e70: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
return -1;
40010e74: 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");
40010e78: 40 00 4c d9 call 400241dc <puts> <== NOT EXECUTED
40010e7c: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
40010e80: 81 c7 e0 08 ret <== NOT EXECUTED
40010e84: 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))
40010e88: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
40010e8c: 08 bf ff b2 bleu 40010d54 <rtems_rfs_format+0xdc> <== NOT EXECUTED
40010e90: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
40010e94: 40 00 4c d2 call 400241dc <puts> <== NOT EXECUTED
40010e98: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 400353a8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
40010e9c: 81 c7 e0 08 ret <== NOT EXECUTED
40010ea0: 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);
40010ea4: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
40010ea8: 40 00 4c 35 call 40023f7c <printf> <== NOT EXECUTED
40010eac: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 400352f8 <_CPU_Trap_slot_template+0x10><== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40010eb0: 10 bf ff 78 b 40010c90 <rtems_rfs_format+0x18> <== NOT EXECUTED
40010eb4: 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);
40010eb8: 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));
40010ebc: 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);
40010ec0: 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));
40010ec4: 92 10 20 ff mov 0xff, %o1
40010ec8: 40 00 4b af call 40023d84 <memset>
40010ecc: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
40010ed0: 82 10 20 28 mov 0x28, %g1
40010ed4: c2 2f 40 00 stb %g1, [ %i5 ]
40010ed8: 82 10 20 09 mov 9, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40010edc: 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);
40010ee0: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
40010ee4: c0 2f 60 05 clrb [ %i5 + 5 ]
40010ee8: c0 2f 60 06 clrb [ %i5 + 6 ]
40010eec: 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);
40010ef0: 84 10 20 01 mov 1, %g2
40010ef4: 82 10 20 20 mov 0x20, %g1
40010ef8: c4 2f 60 03 stb %g2, [ %i5 + 3 ]
40010efc: 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));
40010f00: 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));
40010f04: c2 07 bf 80 ld [ %fp + -128 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f08: c6 2f 60 08 stb %g3, [ %i5 + 8 ]
40010f0c: 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));
40010f10: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f14: c6 2f 60 09 stb %g3, [ %i5 + 9 ]
40010f18: 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));
40010f1c: 87 30 60 18 srl %g1, 0x18, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f20: 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));
40010f24: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f28: c8 2f 60 0a stb %g4, [ %i5 + 0xa ]
40010f2c: 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);
40010f30: 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));
40010f34: 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));
40010f38: 87 30 60 10 srl %g1, 0x10, %g3
40010f3c: 83 30 60 08 srl %g1, 8, %g1
40010f40: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
40010f44: 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);
40010f48: 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);
40010f4c: 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);
40010f50: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
40010f54: c2 17 bf 94 lduh [ %fp + -108 ], %g1
40010f58: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
40010f5c: c2 07 bf 94 ld [ %fp + -108 ], %g1
40010f60: 83 30 60 08 srl %g1, 8, %g1
40010f64: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
40010f68: c2 07 bf 94 ld [ %fp + -108 ], %g1
40010f6c: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40010f70: c2 0f bf 98 ldub [ %fp + -104 ], %g1
40010f74: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
40010f78: c2 17 bf 98 lduh [ %fp + -104 ], %g1
40010f7c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
40010f80: c2 07 bf 98 ld [ %fp + -104 ], %g1
40010f84: 83 30 60 08 srl %g1, 8, %g1
40010f88: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
40010f8c: c2 07 bf 98 ld [ %fp + -104 ], %g1
40010f90: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
40010f94: c2 0f bf a0 ldub [ %fp + -96 ], %g1
40010f98: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
40010f9c: c2 17 bf a0 lduh [ %fp + -96 ], %g1
40010fa0: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
40010fa4: c2 07 bf a0 ld [ %fp + -96 ], %g1
40010fa8: 83 30 60 08 srl %g1, 8, %g1
40010fac: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
40010fb0: c2 07 bf a0 ld [ %fp + -96 ], %g1
40010fb4: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
40010fb8: c2 0f bf a4 ldub [ %fp + -92 ], %g1
40010fbc: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
40010fc0: c2 17 bf a4 lduh [ %fp + -92 ], %g1
40010fc4: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
40010fc8: c2 07 bf a4 ld [ %fp + -92 ], %g1
40010fcc: 83 30 60 08 srl %g1, 8, %g1
40010fd0: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
40010fd4: c2 07 bf a4 ld [ %fp + -92 ], %g1
40010fd8: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
40010fdc: c2 0f bf a8 ldub [ %fp + -88 ], %g1
40010fe0: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
40010fe4: c2 17 bf a8 lduh [ %fp + -88 ], %g1
40010fe8: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
40010fec: c2 07 bf a8 ld [ %fp + -88 ], %g1
40010ff0: 83 30 60 08 srl %g1, 8, %g1
40010ff4: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
40010ff8: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
40010ffc: 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);
40011000: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
40011004: c0 2f 60 25 clrb [ %i5 + 0x25 ]
40011008: c0 2f 60 26 clrb [ %i5 + 0x26 ]
4001100c: 82 10 20 38 mov 0x38, %g1
40011010: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40011014: 40 00 2d 09 call 4001c438 <rtems_rfs_buffer_handle_release>
40011018: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
4001101c: ba 92 20 00 orcc %o0, 0, %i5
40011020: 04 80 00 e3 ble 400113ac <rtems_rfs_format+0x734> <== ALWAYS TAKEN
40011024: 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);
40011028: 40 00 2d 04 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001102c: 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",
40011030: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40011034: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40011038: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
4001103c: 40 00 50 1a call 400250a4 <strerror> <== NOT EXECUTED
40011040: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40011044: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011048: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001104c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011050: 40 00 4b cb call 40023f7c <printf> <== NOT EXECUTED
40011054: 90 12 22 28 or %o0, 0x228, %o0 ! 40035628 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
40011058: 10 bf ff 87 b 40010e74 <rtems_rfs_format+0x1fc> <== NOT EXECUTED
4001105c: 11 10 00 d6 sethi %hi(0x40035800), %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);
40011060: 40 00 38 78 call 4001f240 <rtems_rfs_fs_media_size>
40011064: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
40011068: 80 a2 20 00 cmp %o0, 0
4001106c: 22 80 00 9f be,a 400112e8 <rtems_rfs_format+0x670> <== ALWAYS TAKEN
40011070: 03 00 03 ff sethi %hi(0xffc00), %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40011074: b4 10 20 00 clr %i2 <== NOT EXECUTED
40011078: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4001107c: 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);
40011080: ba 82 40 1b addcc %o1, %i3, %i5 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
40011084: 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);
40011088: b8 42 00 1a addx %o0, %i2, %i4 <== NOT EXECUTED
4001108c: 85 37 60 14 srl %i5, 0x14, %g2 <== NOT EXECUTED
40011090: 89 2f 20 0c sll %i4, 0xc, %g4 <== NOT EXECUTED
40011094: 10 80 00 04 b 400110a4 <rtems_rfs_format+0x42c> <== NOT EXECUTED
40011098: 84 11 00 02 or %g4, %g2, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4001109c: 02 80 00 06 be 400110b4 <rtems_rfs_format+0x43c> <== NOT EXECUTED
400110a0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
400110a4: bb 28 c0 01 sll %g3, %g1, %i5 <== NOT EXECUTED
400110a8: 80 8f 40 02 btst %i5, %g2 <== NOT EXECUTED
400110ac: 02 bf ff fc be 4001109c <rtems_rfs_format+0x424> <== NOT EXECUTED
400110b0: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
400110b4: 80 a7 61 ff cmp %i5, 0x1ff <== NOT EXECUTED
400110b8: 18 80 00 94 bgu 40011308 <rtems_rfs_format+0x690> <== NOT EXECUTED
400110bc: fa 27 bf 84 st %i5, [ %fp + -124 ] <== NOT EXECUTED
400110c0: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
fs->block_size = 512;
400110c4: ba 10 22 00 mov 0x200, %i5
400110c8: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
400110cc: 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)
400110d0: 90 10 00 1d mov %i5, %o0
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
fs->block_size = 512;
400110d4: 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)
400110d8: 40 00 7d 3f call 400305d4 <.urem>
400110dc: 92 10 00 1c mov %i4, %o1
400110e0: 80 a2 20 00 cmp %o0, 0
400110e4: 22 bf ff 17 be,a 40010d40 <rtems_rfs_format+0xc8> <== ALWAYS TAKEN
400110e8: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400110ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400110f0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400110f4: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
400110f8: 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",
400110fc: 40 00 4b a0 call 40023f7c <printf> <== NOT EXECUTED
40011100: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
40011104: 81 c7 e0 08 ret <== NOT EXECUTED
40011108: 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",
4001110c: 40 00 38 4d call 4001f240 <rtems_rfs_fs_media_size> <== NOT EXECUTED
40011110: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40011114: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
40011118: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001111c: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
40011120: 40 00 4b 97 call 40023f7c <printf> <== NOT EXECUTED
40011124: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 400353d8 <_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));
40011128: 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",
4001112c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011130: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
40011134: 40 00 4b 92 call 40023f7c <printf> <== NOT EXECUTED
40011138: 90 12 20 00 mov %o0, %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));
4001113c: 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",
40011140: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011144: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
40011148: 40 00 4b 8d call 40023f7c <printf> <== NOT EXECUTED
4001114c: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
40011150: 40 00 38 33 call 4001f21c <rtems_rfs_fs_size> <== NOT EXECUTED
40011154: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40011158: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
4001115c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40011160: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011164: 40 00 4b 86 call 40023f7c <printf> <== NOT EXECUTED
40011168: 90 12 20 58 or %o0, 0x58, %o0 ! 40035458 <_CPU_Trap_slot_template+0x170><== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
4001116c: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
40011170: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011174: 40 00 4b 82 call 40023f7c <printf> <== NOT EXECUTED
40011178: 90 12 20 78 or %o0, 0x78, %o0 ! 40035478 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
4001117c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
40011180: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011184: 40 00 4b 7e call 40023f7c <printf> <== NOT EXECUTED
40011188: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400354a0 <_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));
4001118c: 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",
40011190: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011194: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
40011198: 40 00 4b 79 call 40023f7c <printf> <== NOT EXECUTED
4001119c: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
400111a0: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
400111a4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
400111a8: 40 00 4b 75 call 40023f7c <printf> <== NOT EXECUTED
400111ac: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400354f0 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400111b0: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
400111b4: 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",
400111b8: 7f ff c5 00 call 400025b8 <.umul> <== NOT EXECUTED
400111bc: 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,
400111c0: 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",
400111c4: 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,
400111c8: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
400111cc: 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)
400111d0: ba a7 40 01 subcc %i5, %g1, %i5 <== NOT EXECUTED
400111d4: 12 80 00 55 bne 40011328 <rtems_rfs_format+0x6b0> <== NOT EXECUTED
400111d8: 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))
400111dc: 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));
400111e0: 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))
400111e4: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
400111e8: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
400111ec: 28 80 00 02 bleu,a 400111f4 <rtems_rfs_format+0x57c> <== NOT EXECUTED
400111f0: 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;
400111f4: 7f ff c5 2d call 400026a8 <.div> <== NOT EXECUTED
400111f8: 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",
400111fc: 92 10 20 0a mov 0xa, %o1 ! a <PROM_START+0xa> <== NOT EXECUTED
40011200: 7f ff c5 2a call 400026a8 <.div> <== NOT EXECUTED
40011204: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
40011208: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
4001120c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40011210: 40 00 7c f3 call 400305dc <.rem> <== NOT EXECUTED
40011214: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40011218: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001121c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40011220: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40011224: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011228: 40 00 4b 55 call 40023f7c <printf> <== NOT EXECUTED
4001122c: 90 12 21 18 or %o0, 0x118, %o0 ! 40035518 <_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);
40011230: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
40011234: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011238: 40 00 4b 51 call 40023f7c <printf> <== NOT EXECUTED
4001123c: 90 12 21 48 or %o0, 0x148, %o0 ! 40035548 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
40011240: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
40011244: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011248: 40 00 4b 4d call 40023f7c <printf> <== NOT EXECUTED
4001124c: 90 12 21 68 or %o0, 0x168, %o0 ! 40035568 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
40011250: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
40011254: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40011258: 40 00 4b 49 call 40023f7c <printf> <== NOT EXECUTED
4001125c: 90 12 21 90 or %o0, 0x190, %o0 ! 40035590 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
40011260: 10 bf fe e8 b 40010e00 <rtems_rfs_format+0x188> <== NOT EXECUTED
40011264: 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)
40011268: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001126c: 02 bf fe df be 40010de8 <rtems_rfs_format+0x170> <== NOT EXECUTED
40011270: 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;
40011274: 10 bf fe df b 40010df0 <rtems_rfs_format+0x178> <== NOT EXECUTED
40011278: 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)
4001127c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40011280: 80 a0 60 00 cmp %g1, 0
40011284: 02 80 00 03 be 40011290 <rtems_rfs_format+0x618> <== ALWAYS TAKEN
40011288: 90 10 20 01 mov 1, %o0
4001128c: 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;
40011290: 7f ff c4 ca call 400025b8 <.umul>
40011294: 92 07 3f ff add %i4, -1, %o1
40011298: 92 10 20 64 mov 0x64, %o1
4001129c: 7f ff c5 01 call 400026a0 <.udiv>
400112a0: b6 10 20 01 mov 1, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
400112a4: 80 a2 20 00 cmp %o0, 0
400112a8: 32 80 00 30 bne,a 40011368 <rtems_rfs_format+0x6f0>
400112ac: 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);
400112b0: 92 10 20 38 mov 0x38, %o1
400112b4: 7f ff c4 fb call 400026a0 <.udiv>
400112b8: 90 10 00 1d mov %i5, %o0
400112bc: b8 10 00 08 mov %o0, %i4
400112c0: 90 10 00 1b mov %i3, %o0
400112c4: 7f ff c4 bd call 400025b8 <.umul>
400112c8: 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;
400112cc: 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);
400112d0: b6 10 00 08 mov %o0, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
400112d4: 80 a6 e0 00 cmp %i3, 0
400112d8: 02 bf fe bc be 40010dc8 <rtems_rfs_format+0x150> <== NEVER TAKEN
400112dc: 90 10 20 01 mov 1, %o0
return 1;
return ((dividend - 1) / divisor) + 1;
400112e0: 10 bf fe b7 b 40010dbc <rtems_rfs_format+0x144>
400112e4: 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))
400112e8: 82 10 63 ff or %g1, 0x3ff, %g1
400112ec: 80 a2 40 01 cmp %o1, %g1
400112f0: 18 bf ff 62 bgu 40011078 <rtems_rfs_format+0x400> <== NEVER TAKEN
400112f4: b4 10 20 00 clr %i2
400112f8: fa 07 bf 84 ld [ %fp + -124 ], %i5
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
400112fc: 80 a7 61 ff cmp %i5, 0x1ff
40011300: 08 bf ff 71 bleu 400110c4 <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
40011304: c2 07 bf 8c ld [ %fp + -116 ], %g1
fs->block_size = 512;
if (fs->block_size > (4 * 1024))
40011308: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
4001130c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
40011310: 08 80 02 06 bleu 40011b28 <rtems_rfs_format+0xeb0> <== NOT EXECUTED
40011314: c4 07 bf 8c ld [ %fp + -116 ], %g2 <== NOT EXECUTED
fs->block_size = (4 * 1024);
40011318: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
4001131c: f8 00 a0 20 ld [ %g2 + 0x20 ], %i4 <== NOT EXECUTED
40011320: 10 bf fe 81 b 40010d24 <rtems_rfs_format+0xac> <== NOT EXECUTED
40011324: 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;
40011328: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001132c: 7f ff c4 dd call 400026a0 <.udiv> <== NOT EXECUTED
40011330: 90 07 7f ff add %i5, -1, %o0 <== NOT EXECUTED
40011334: 90 02 20 02 add %o0, 2, %o0 <== NOT EXECUTED
40011338: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
4001133c: 85 2a 20 07 sll %o0, 7, %g2 <== NOT EXECUTED
40011340: 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))
40011344: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
40011348: 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));
4001134c: 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))
40011350: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
40011354: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
40011358: 18 bf ff a7 bgu 400111f4 <rtems_rfs_format+0x57c> <== NOT EXECUTED
4001135c: 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));
40011360: 10 bf ff a5 b 400111f4 <rtems_rfs_format+0x57c> <== NOT EXECUTED
40011364: 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;
40011368: 7f ff c4 ce call 400026a0 <.udiv>
4001136c: 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);
40011370: 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;
40011374: 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);
40011378: 7f ff c4 ca call 400026a0 <.udiv>
4001137c: 90 10 00 1d mov %i5, %o0
40011380: b8 10 00 08 mov %o0, %i4
40011384: 90 10 00 1b mov %i3, %o0
40011388: 7f ff c4 8c call 400025b8 <.umul>
4001138c: 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;
40011390: 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);
40011394: b6 10 00 08 mov %o0, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
40011398: 80 a6 e0 00 cmp %i3, 0
4001139c: 02 bf fe 8b be 40010dc8 <rtems_rfs_format+0x150> <== NEVER TAKEN
400113a0: 90 10 20 01 mov 1, %o0
return 1;
return ((dividend - 1) / divisor) + 1;
400113a4: 10 bf fe 86 b 40010dbc <rtems_rfs_format+0x144>
400113a8: 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);
400113ac: 90 07 bf 7c add %fp, -132, %o0
400113b0: 40 00 2c 22 call 4001c438 <rtems_rfs_buffer_handle_release>
400113b4: 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++)
400113b8: c2 07 bf a0 ld [ %fp + -96 ], %g1
400113bc: 80 a0 60 00 cmp %g1, 0
400113c0: 04 80 01 36 ble 40011898 <rtems_rfs_format+0xc20> <== NEVER TAKEN
400113c4: c2 07 bf 80 ld [ %fp + -128 ], %g1
if (!rtems_rfs_write_group (&fs, group,
400113c8: e2 0e 60 14 ldub [ %i1 + 0x14 ], %l1
400113cc: 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))
400113d0: 80 a0 60 00 cmp %g1, 0
400113d4: 02 80 01 2f be 40011890 <rtems_rfs_format+0xc18> <== NEVER TAKEN
400113d8: 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",
400113dc: 27 10 00 d5 sethi %hi(0x40035400), %l3
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
400113e0: 25 10 00 d5 sethi %hi(0x40035400), %l2
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
400113e4: 2b 10 00 d5 sethi %hi(0x40035400), %l5
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
400113e8: b6 10 20 01 mov 1, %i3
400113ec: a0 10 20 00 clr %l0
400113f0: 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",
400113f4: a6 14 e2 a8 or %l3, 0x2a8, %l3
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
400113f8: a4 14 a2 e0 or %l2, 0x2e0, %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);
400113fc: a8 10 20 01 mov 1, %l4
if (verbose)
printf (", inodes");
40011400: aa 15 63 d0 or %l5, 0x3d0, %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))
40011404: 86 06 c0 1c add %i3, %i4, %g3
40011408: 80 a0 c0 01 cmp %g3, %g1
4001140c: 38 80 00 02 bgu,a 40011414 <rtems_rfs_format+0x79c> <== ALWAYS TAKEN
40011410: b8 20 40 1b sub %g1, %i3, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
40011414: ac 88 a0 ff andcc %g2, 0xff, %l6
40011418: 12 80 00 3b bne 40011504 <rtems_rfs_format+0x88c> <== NEVER TAKEN
4001141c: 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;
40011420: c0 2f bf 30 clrb [ %fp + -208 ]
handle->bnum = 0;
40011424: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
40011428: 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,
4001142c: 90 07 bf 3c add %fp, -196, %o0
40011430: 92 07 bf 7c add %fp, -132, %o1
40011434: 94 07 bf 30 add %fp, -208, %o2
40011438: 96 10 00 1c mov %i4, %o3
4001143c: 40 00 27 66 call 4001b1d4 <rtems_rfs_bitmap_open>
40011440: 98 10 00 1b mov %i3, %o4
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40011444: ba 92 20 00 orcc %o0, 0, %i5
40011448: 04 80 00 12 ble 40011490 <rtems_rfs_format+0x818> <== ALWAYS TAKEN
4001144c: 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);
40011450: 40 00 2b fa call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011454: 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",
40011458: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001145c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40011460: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
40011464: 40 00 4f 10 call 400250a4 <strerror> <== NOT EXECUTED
40011468: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
4001146c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40011470: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40011474: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40011478: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
4001147c: 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",
40011480: 40 00 4a bf call 40023f7c <printf> <== NOT EXECUTED
40011484: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
40011488: 81 c7 e0 08 ret <== NOT EXECUTED
4001148c: 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));
40011490: c2 07 bf 38 ld [ %fp + -200 ], %g1
40011494: d4 07 bf 84 ld [ %fp + -124 ], %o2
40011498: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001149c: 40 00 4a 3a call 40023d84 <memset>
400114a0: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
400114a4: 40 00 26 a4 call 4001af34 <rtems_rfs_bitmap_map_clear_all>
400114a8: 90 07 bf 3c add %fp, -196, %o0
if (rc > 0)
400114ac: ba 92 20 00 orcc %o0, 0, %i5
400114b0: 04 80 00 20 ble 40011530 <rtems_rfs_format+0x8b8> <== ALWAYS TAKEN
400114b4: 92 10 20 00 clr %o1
{
rtems_rfs_bitmap_close (&bitmap);
400114b8: 40 00 27 58 call 4001b218 <rtems_rfs_bitmap_close> <== NOT EXECUTED
400114bc: 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);
400114c0: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
400114c4: 40 00 2b dd call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400114c8: 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",
400114cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400114d0: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400114d4: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400114d8: 40 00 4e f3 call 400250a4 <strerror> <== NOT EXECUTED
400114dc: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400114e0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400114e4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400114e8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400114ec: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
400114f0: 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",
400114f4: 40 00 4a a2 call 40023f7c <printf> <== NOT EXECUTED
400114f8: 90 12 23 38 or %o0, 0x338, %o0 <== NOT EXECUTED
400114fc: 81 c7 e0 08 ret <== NOT EXECUTED
40011500: 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",
40011504: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40011508: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001150c: 40 00 4a 9c call 40023f7c <printf> <== NOT EXECUTED
40011510: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
40011514: 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;
40011518: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
4001151c: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
40011520: 40 00 4a 97 call 40023f7c <printf> <== NOT EXECUTED
40011524: 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,
40011528: 10 bf ff c2 b 40011430 <rtems_rfs_format+0x7b8> <== NOT EXECUTED
4001152c: 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);
40011530: 40 00 25 fa call 4001ad18 <rtems_rfs_bitmap_map_set>
40011534: 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);
40011538: 92 10 20 01 mov 1, %o1
4001153c: 40 00 25 f7 call 4001ad18 <rtems_rfs_bitmap_map_set>
40011540: 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);
40011544: 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)
40011548: 80 a2 20 00 cmp %o0, 0
4001154c: 12 80 00 2b bne 400115f8 <rtems_rfs_format+0x980> <== ALWAYS TAKEN
40011550: d2 07 bf ac ld [ %fp + -84 ], %o1
return 1;
40011554: ae 10 20 01 mov 1, %l7 <== NOT EXECUTED
40011558: 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);
4001155c: 92 07 60 02 add %i5, 2, %o1
40011560: 40 00 25 ee call 4001ad18 <rtems_rfs_bitmap_map_set>
40011564: 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++)
40011568: ba 07 60 01 inc %i5
4001156c: 80 a7 40 17 cmp %i5, %l7
40011570: 06 bf ff fc bl 40011560 <rtems_rfs_format+0x8e8>
40011574: 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);
40011578: 40 00 27 28 call 4001b218 <rtems_rfs_bitmap_close>
4001157c: 90 07 bf 3c add %fp, -196, %o0
if (rc > 0)
40011580: ba 92 20 00 orcc %o0, 0, %i5
40011584: 14 80 00 24 bg 40011614 <rtems_rfs_format+0x99c> <== NEVER TAKEN
40011588: 80 a5 a0 00 cmp %l6, 0
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
4001158c: 12 80 00 50 bne 400116cc <rtems_rfs_format+0xa54> <== NEVER TAKEN
40011590: 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,
40011594: 90 07 bf 3c add %fp, -196, %o0
40011598: 92 07 bf 7c add %fp, -132, %o1
4001159c: 94 07 bf 30 add %fp, -208, %o2
400115a0: 96 10 00 1c mov %i4, %o3
400115a4: 40 00 27 0c call 4001b1d4 <rtems_rfs_bitmap_open>
400115a8: 98 04 20 02 add %l0, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
400115ac: ba 92 20 00 orcc %o0, 0, %i5
400115b0: 04 80 00 2a ble 40011658 <rtems_rfs_format+0x9e0> <== ALWAYS TAKEN
400115b4: 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);
400115b8: 40 00 2b a0 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400115bc: 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",
400115c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400115c4: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400115c8: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400115cc: 40 00 4e b6 call 400250a4 <strerror> <== NOT EXECUTED
400115d0: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400115d4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400115d8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400115dc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400115e0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
400115e4: 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",
400115e8: 40 00 4a 65 call 40023f7c <printf> <== NOT EXECUTED
400115ec: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED
400115f0: 81 c7 e0 08 ret <== NOT EXECUTED
400115f4: 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;
400115f8: 7f ff c4 2a call 400026a0 <.udiv>
400115fc: 90 02 3f ff add %o0, -1, %o0
40011600: 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++)
40011604: 80 a5 e0 00 cmp %l7, 0
40011608: 14 bf ff d5 bg 4001155c <rtems_rfs_format+0x8e4> <== ALWAYS TAKEN
4001160c: ba 10 20 00 clr %i5
40011610: 30 bf ff da b,a 40011578 <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);
40011614: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40011618: 40 00 2b 88 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001161c: 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",
40011620: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40011624: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40011628: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
4001162c: 40 00 4e 9e call 400250a4 <strerror> <== NOT EXECUTED
40011630: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40011634: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40011638: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001163c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40011640: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
40011644: 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",
40011648: 40 00 4a 4d call 40023f7c <printf> <== NOT EXECUTED
4001164c: 90 12 23 88 or %o0, 0x388, %o0 <== NOT EXECUTED
40011650: 81 c7 e0 08 ret <== NOT EXECUTED
40011654: 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));
40011658: c2 07 bf 38 ld [ %fp + -200 ], %g1
4001165c: d4 07 bf 84 ld [ %fp + -124 ], %o2
40011660: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40011664: 40 00 49 c8 call 40023d84 <memset>
40011668: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4001166c: 40 00 26 32 call 4001af34 <rtems_rfs_bitmap_map_clear_all>
40011670: 90 07 bf 3c add %fp, -196, %o0
40011674: ba 10 00 08 mov %o0, %i5
if (rc > 0)
40011678: 80 a7 60 00 cmp %i5, 0
4001167c: 04 80 00 21 ble 40011700 <rtems_rfs_format+0xa88> <== ALWAYS TAKEN
40011680: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
40011684: 40 00 26 e5 call 4001b218 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40011688: 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);
4001168c: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40011690: 40 00 2b 6a call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011694: 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" \
40011698: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001169c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400116a0: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400116a4: 40 00 4e 80 call 400250a4 <strerror> <== NOT EXECUTED
400116a8: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400116ac: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400116b0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400116b4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400116b8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400116bc: 40 00 4a 30 call 40023f7c <printf> <== NOT EXECUTED
400116c0: 90 12 20 28 or %o0, 0x28, %o0 ! 40035828 <_CPU_Trap_slot_template+0x540><== NOT EXECUTED
400116c4: 81 c7 e0 08 ret <== NOT EXECUTED
400116c8: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
400116cc: 40 00 4a 2c call 40023f7c <printf> <== NOT EXECUTED
400116d0: 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,
400116d4: 10 bf ff b1 b 40011598 <rtems_rfs_format+0x920> <== NOT EXECUTED
400116d8: 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",
400116dc: 40 00 4e 72 call 400250a4 <strerror> <== NOT EXECUTED
400116e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400116e4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400116e8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400116ec: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
400116f0: 40 00 4a 23 call 40023f7c <printf> <== NOT EXECUTED
400116f4: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400355b8 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
400116f8: 81 c7 e0 08 ret <== NOT EXECUTED
400116fc: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
40011700: 40 00 26 c6 call 4001b218 <rtems_rfs_bitmap_close>
40011704: 01 00 00 00 nop
if (rc > 0)
40011708: ba 92 20 00 orcc %o0, 0, %i5
4001170c: 14 80 00 2a bg 400117b4 <rtems_rfs_format+0xb3c> <== NEVER TAKEN
40011710: 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)
40011714: 02 80 00 46 be 4001182c <rtems_rfs_format+0xbb4> <== ALWAYS TAKEN
40011718: e8 2f bf 30 stb %l4, [ %fp + -208 ]
{
for (b = 0; b < blocks; b++)
4001171c: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
40011720: 04 80 00 43 ble 4001182c <rtems_rfs_format+0xbb4> <== NOT EXECUTED
40011724: 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)
40011728: 10 80 00 0a b 40011750 <rtems_rfs_format+0xad8> <== NOT EXECUTED
4001172c: 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));
40011730: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED
40011734: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
40011738: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
4001173c: 40 00 49 92 call 40023d84 <memset> <== NOT EXECUTED
40011740: 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++)
40011744: 80 a6 c0 17 cmp %i3, %l7 <== NOT EXECUTED
40011748: 02 80 00 39 be 4001182c <rtems_rfs_format+0xbb4> <== NOT EXECUTED
4001174c: e8 2f bf 30 stb %l4, [ %fp + -208 ] <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40011750: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40011754: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40011758: 96 10 20 00 clr %o3 <== NOT EXECUTED
4001175c: 40 00 2b b1 call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40011760: 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));
40011764: 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)
40011768: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001176c: 04 bf ff f1 ble 40011730 <rtems_rfs_format+0xab8> <== NOT EXECUTED
40011770: 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);
40011774: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40011778: 40 00 2b 30 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001177c: 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",
40011780: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40011784: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40011788: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
4001178c: 40 00 4e 46 call 400250a4 <strerror> <== NOT EXECUTED
40011790: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40011794: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40011798: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001179c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
400117a0: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400117a4: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
400117a8: 40 00 49 f5 call 40023f7c <printf> <== NOT EXECUTED
400117ac: 90 12 20 c0 or %o0, 0xc0, %o0 <== NOT EXECUTED
400117b0: 30 bf fd bb b,a 40010e9c <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);
400117b4: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
400117b8: 40 00 2b 20 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400117bc: 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" \
400117c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400117c4: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400117c8: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400117cc: 40 00 4e 36 call 400250a4 <strerror> <== NOT EXECUTED
400117d0: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400117d4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400117d8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400117dc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400117e0: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400117e4: 40 00 49 e6 call 40023f7c <printf> <== NOT EXECUTED
400117e8: 90 12 20 78 or %o0, 0x78, %o0 ! 40035878 <_CPU_Trap_slot_template+0x590><== NOT EXECUTED
400117ec: 30 bf fd ac b,a 40010e9c <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",
400117f0: 40 00 4e 2d call 400250a4 <strerror> <== NOT EXECUTED
400117f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400117f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400117fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011800: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
40011804: 40 00 49 de call 40023f7c <printf> <== NOT EXECUTED
40011808: 90 12 23 10 or %o0, 0x310, %o0 ! 40035310 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
4001180c: 81 c7 e0 08 ret <== NOT EXECUTED
40011810: 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",
40011814: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
return -1;
40011818: 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",
4001181c: 40 00 49 d8 call 40023f7c <printf> <== NOT EXECUTED
40011820: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
40011824: 81 c7 e0 08 ret <== NOT EXECUTED
40011828: 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);
4001182c: 90 07 bf 7c add %fp, -132, %o0
40011830: 40 00 2b 02 call 4001c438 <rtems_rfs_buffer_handle_release>
40011834: 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++)
40011838: c2 07 bf a0 ld [ %fp + -96 ], %g1
4001183c: b4 06 a0 01 inc %i2
40011840: 80 a0 40 1a cmp %g1, %i2
40011844: 04 80 00 15 ble 40011898 <rtems_rfs_format+0xc20> <== ALWAYS TAKEN
40011848: 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);
4001184c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40011850: 7f ff c3 5a call 400025b8 <.umul> <== NOT EXECUTED
40011854: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
40011858: 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);
4001185c: b6 02 20 01 add %o0, 1, %i3 <== NOT EXECUTED
40011860: 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,
40011864: 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))
40011868: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
4001186c: 08 bf fe e6 bleu 40011404 <rtems_rfs_format+0x78c> <== NOT EXECUTED
40011870: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2 <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40011874: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40011878: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
4001187c: 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",
40011880: 40 00 49 bf call 40023f7c <printf> <== NOT EXECUTED
40011884: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
40011888: 81 c7 e0 08 ret <== NOT EXECUTED
4001188c: 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))
40011890: 10 bf ff f9 b 40011874 <rtems_rfs_format+0xbfc> <== NOT EXECUTED
40011894: 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)
40011898: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
4001189c: 80 a0 60 00 cmp %g1, 0
400118a0: 02 80 00 04 be 400118b0 <rtems_rfs_format+0xc38> <== ALWAYS TAKEN
400118a4: 01 00 00 00 nop
printf ("\n");
400118a8: 40 00 4a 1f call 40024124 <putchar> <== NOT EXECUTED
400118ac: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
400118b0: 40 00 2d 10 call 4001ccf0 <rtems_rfs_buffer_close>
400118b4: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
400118b8: ba 92 20 00 orcc %o0, 0, %i5
400118bc: 14 80 00 43 bg 400119c8 <rtems_rfs_format+0xd50> <== NEVER TAKEN
400118c0: 92 10 20 00 clr %o1
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
400118c4: 90 10 00 18 mov %i0, %o0
400118c8: 94 10 20 06 mov 6, %o2
400118cc: 96 10 20 00 clr %o3
400118d0: 40 00 36 66 call 4001f268 <rtems_rfs_fs_open>
400118d4: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
400118d8: 80 a2 20 00 cmp %o0, 0
400118dc: 06 80 00 7b bl 40011ac8 <rtems_rfs_format+0xe50> <== NEVER TAKEN
400118e0: 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);
400118e4: d0 07 bf 28 ld [ %fp + -216 ], %o0
400118e8: 40 00 02 8c call 40012318 <rtems_rfs_inode_alloc>
400118ec: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
400118f0: ba 92 20 00 orcc %o0, 0, %i5
400118f4: 14 80 00 0c bg 40011924 <rtems_rfs_format+0xcac> <== NEVER TAKEN
400118f8: d2 07 bf 2c ld [ %fp + -212 ], %o1
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
400118fc: 80 a2 60 01 cmp %o1, 1
40011900: 02 80 00 1c be 40011970 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
40011904: 11 10 00 d6 sethi %hi(0x40035800), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40011908: 40 00 49 9d call 40023f7c <printf> <== NOT EXECUTED
4001190c: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400359a8 <_CPU_Trap_slot_template+0x6c0><== NOT EXECUTED
rtems_rfs_fs_close (fs);
40011910: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40011914: 40 00 38 81 call 4001fb18 <rtems_rfs_fs_close> <== NOT EXECUTED
40011918: b0 10 20 00 clr %i0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
4001191c: 81 c7 e0 08 ret <== NOT EXECUTED
40011920: 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",
40011924: 40 00 4d e0 call 400250a4 <strerror> <== NOT EXECUTED
40011928: 01 00 00 00 nop <== NOT EXECUTED
4001192c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011930: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011934: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011938: 40 00 49 91 call 40023f7c <printf> <== NOT EXECUTED
4001193c: 90 12 21 70 or %o0, 0x170, %o0 ! 40035970 <_CPU_Trap_slot_template+0x688><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
40011940: 40 00 38 76 call 4001fb18 <rtems_rfs_fs_close> <== NOT EXECUTED
40011944: 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",
40011948: 40 00 4d d7 call 400250a4 <strerror> <== NOT EXECUTED
4001194c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011950: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011954: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
rc, strerror (rc));
return -1;
40011958: 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",
4001195c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011960: 40 00 49 87 call 40023f7c <printf> <== NOT EXECUTED
40011964: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40035ae8 <_CPU_Trap_slot_template+0x800><== NOT EXECUTED
40011968: 81 c7 e0 08 ret <== NOT EXECUTED
4001196c: 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);
40011970: d0 07 bf 28 ld [ %fp + -216 ], %o0
40011974: 92 10 20 01 mov 1, %o1
40011978: 94 07 bf 54 add %fp, -172, %o2
4001197c: 40 00 02 a3 call 40012408 <rtems_rfs_inode_open>
40011980: 96 10 20 01 mov 1, %o3
if (rc > 0)
40011984: ba 92 20 00 orcc %o0, 0, %i5
40011988: 24 80 00 19 ble,a 400119ec <rtems_rfs_format+0xd74> <== ALWAYS TAKEN
4001198c: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
40011990: 40 00 4d c5 call 400250a4 <strerror> <== NOT EXECUTED
40011994: 01 00 00 00 nop <== NOT EXECUTED
40011998: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001199c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400119a0: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400119a4: 40 00 49 76 call 40023f7c <printf> <== NOT EXECUTED
400119a8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400359e0 <_CPU_Trap_slot_template+0x6f8><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
400119ac: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
400119b0: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
400119b4: 40 00 01 a7 call 40012050 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
400119b8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
rtems_rfs_fs_close (fs);
400119bc: 40 00 38 57 call 4001fb18 <rtems_rfs_fs_close> <== NOT EXECUTED
400119c0: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
400119c4: 30 bf ff e1 b,a 40011948 <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",
400119c8: 40 00 4d b7 call 400250a4 <strerror> <== NOT EXECUTED
400119cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400119d0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400119d4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400119d8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400119dc: 40 00 49 68 call 40023f7c <printf> <== NOT EXECUTED
400119e0: 90 12 21 08 or %o0, 0x108, %o0 ! 40035908 <_CPU_Trap_slot_template+0x620><== NOT EXECUTED
400119e4: 81 c7 e0 08 ret <== NOT EXECUTED
400119e8: 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,
400119ec: 92 10 20 00 clr %o1
400119f0: 96 10 20 00 clr %o3
400119f4: 15 00 00 10 sethi %hi(0x4000), %o2
400119f8: 98 10 20 00 clr %o4
400119fc: 40 00 03 7f call 400127f8 <rtems_rfs_inode_initialise>
40011a00: 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)
40011a04: ba 92 20 00 orcc %o0, 0, %i5
40011a08: 24 80 00 0a ble,a 40011a30 <rtems_rfs_format+0xdb8> <== ALWAYS TAKEN
40011a0c: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
40011a10: 40 00 4d a5 call 400250a4 <strerror> <== NOT EXECUTED
40011a14: 01 00 00 00 nop <== NOT EXECUTED
40011a18: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011a1c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011a20: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011a24: 40 00 49 56 call 40023f7c <printf> <== NOT EXECUTED
40011a28: 90 12 22 10 or %o0, 0x210, %o0 ! 40035a10 <_CPU_Trap_slot_template+0x728><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40011a2c: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40011a30: d8 07 bf 2c ld [ %fp + -212 ], %o4
40011a34: 92 07 bf 54 add %fp, -172, %o1
40011a38: 96 10 20 01 mov 1, %o3
40011a3c: 15 10 00 cf sethi %hi(0x40033c00), %o2
40011a40: 40 00 2e 39 call 4001d324 <rtems_rfs_dir_add_entry>
40011a44: 94 12 a0 10 or %o2, 0x10, %o2 ! 40033c10 <flashdisk_ops+0x1c>
if (rc > 0)
40011a48: ba 92 20 00 orcc %o0, 0, %i5
40011a4c: 24 80 00 0a ble,a 40011a74 <rtems_rfs_format+0xdfc> <== ALWAYS TAKEN
40011a50: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40011a54: 40 00 4d 94 call 400250a4 <strerror> <== NOT EXECUTED
40011a58: 01 00 00 00 nop <== NOT EXECUTED
40011a5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011a60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011a64: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011a68: 40 00 49 45 call 40023f7c <printf> <== NOT EXECUTED
40011a6c: 90 12 22 48 or %o0, 0x248, %o0 ! 40035a48 <_CPU_Trap_slot_template+0x760><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
40011a70: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40011a74: 40 00 02 dd call 400125e8 <rtems_rfs_inode_close>
40011a78: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
40011a7c: ba 92 20 00 orcc %o0, 0, %i5
40011a80: 04 80 00 09 ble 40011aa4 <rtems_rfs_format+0xe2c> <== ALWAYS TAKEN
40011a84: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40011a88: 40 00 4d 87 call 400250a4 <strerror> <== NOT EXECUTED
40011a8c: 01 00 00 00 nop <== NOT EXECUTED
40011a90: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011a94: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011a98: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011a9c: 40 00 49 38 call 40023f7c <printf> <== NOT EXECUTED
40011aa0: 90 12 22 80 or %o0, 0x280, %o0 ! 40035a80 <_CPU_Trap_slot_template+0x798><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
40011aa4: 40 00 38 1d call 4001fb18 <rtems_rfs_fs_close>
40011aa8: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
40011aac: ba 92 20 00 orcc %o0, 0, %i5
40011ab0: 06 80 00 12 bl 40011af8 <rtems_rfs_format+0xe80> <== NEVER TAKEN
40011ab4: 80 a7 60 00 cmp %i5, 0
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
40011ab8: 12 bf ff a4 bne 40011948 <rtems_rfs_format+0xcd0> <== NEVER TAKEN
40011abc: b0 10 20 00 clr %i0
rc, strerror (rc));
return -1;
}
return 0;
}
40011ac0: 81 c7 e0 08 ret
40011ac4: 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));
40011ac8: 40 00 43 9c call 40022938 <__errno> <== NOT EXECUTED
40011acc: b0 10 20 00 clr %i0 <== NOT EXECUTED
40011ad0: 40 00 43 9a call 40022938 <__errno> <== NOT EXECUTED
40011ad4: 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",
40011ad8: 40 00 4d 73 call 400250a4 <strerror> <== NOT EXECUTED
40011adc: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40011ae0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011ae4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011ae8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011aec: 40 00 49 24 call 40023f7c <printf> <== NOT EXECUTED
40011af0: 90 12 21 38 or %o0, 0x138, %o0 ! 40035938 <_CPU_Trap_slot_template+0x650><== NOT EXECUTED
40011af4: 30 bf ff f3 b,a 40011ac0 <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));
40011af8: 40 00 43 90 call 40022938 <__errno> <== NOT EXECUTED
40011afc: b0 10 20 00 clr %i0 <== NOT EXECUTED
40011b00: 40 00 43 8e call 40022938 <__errno> <== NOT EXECUTED
40011b04: 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",
40011b08: 40 00 4d 67 call 400250a4 <strerror> <== NOT EXECUTED
40011b0c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40011b10: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40011b14: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011b18: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011b1c: 40 00 49 18 call 40023f7c <printf> <== NOT EXECUTED
40011b20: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40035ab0 <_CPU_Trap_slot_template+0x7c8><== NOT EXECUTED
40011b24: 30 bf ff e7 b,a 40011ac0 <rtems_rfs_format+0xe48> <== NOT EXECUTED
40011b28: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
40011b2c: 10 bf fc 7e b 40010d24 <rtems_rfs_format+0xac> <== NOT EXECUTED
40011b30: f8 00 60 20 ld [ %g1 + 0x20 ], %i4 <== NOT EXECUTED
4001fb18 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
4001fb18: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
4001fb1c: 90 10 20 00 clr %o0
4001fb20: 7f ff d0 e1 call 40013ea4 <rtems_rfs_trace>
4001fb24: 92 10 20 02 mov 2, %o1
4001fb28: 80 8a 20 ff btst 0xff, %o0
4001fb2c: 12 80 00 17 bne 4001fb88 <rtems_rfs_fs_close+0x70> <== NEVER TAKEN
4001fb30: 11 10 00 df sethi %hi(0x40037c00), %o0
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
4001fb34: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001fb38: b8 10 20 00 clr %i4
4001fb3c: 80 a0 60 00 cmp %g1, 0
4001fb40: 04 80 00 0b ble 4001fb6c <rtems_rfs_fs_close+0x54> <== NEVER TAKEN
4001fb44: ba 10 20 00 clr %i5
rtems_rfs_group_close (fs, &fs->groups[group]);
4001fb48: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
4001fb4c: 90 10 00 18 mov %i0, %o0
4001fb50: 7f ff c8 86 call 40011d68 <rtems_rfs_group_close>
4001fb54: 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++)
4001fb58: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001fb5c: ba 07 60 01 inc %i5
4001fb60: 80 a0 40 1d cmp %g1, %i5
4001fb64: 14 bf ff f9 bg 4001fb48 <rtems_rfs_fs_close+0x30> <== NEVER TAKEN
4001fb68: b8 07 20 50 add %i4, 0x50, %i4
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
4001fb6c: 7f ff f4 61 call 4001ccf0 <rtems_rfs_buffer_close>
4001fb70: 90 10 00 18 mov %i0, %o0
free (fs);
4001fb74: 90 10 00 18 mov %i0, %o0
4001fb78: 7f ff a0 f4 call 40007f48 <free>
4001fb7c: b0 10 20 00 clr %i0
return 0;
}
4001fb80: 81 c7 e0 08 ret
4001fb84: 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");
4001fb88: 40 00 11 95 call 400241dc <puts> <== NOT EXECUTED
4001fb8c: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
4001fb90: 10 bf ff ea b 4001fb38 <rtems_rfs_fs_close+0x20> <== NOT EXECUTED
4001fb94: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
4001f268 <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)
{
4001f268: 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))
4001f26c: 90 10 20 00 clr %o0
4001f270: 7f ff d3 0d call 40013ea4 <rtems_rfs_trace>
4001f274: 92 10 20 01 mov 1, %o1
4001f278: 80 8a 20 ff btst 0xff, %o0
4001f27c: 12 80 00 82 bne 4001f484 <rtems_rfs_fs_open+0x21c> <== NEVER TAKEN
4001f280: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
4001f284: 7f ff a4 ce call 400085bc <malloc>
4001f288: 90 10 20 84 mov 0x84, %o0
if (!*fs)
4001f28c: 80 a2 20 00 cmp %o0, 0
4001f290: 02 80 01 68 be 4001f830 <rtems_rfs_fs_open+0x5c8> <== NEVER TAKEN
4001f294: 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));
4001f298: 92 10 20 00 clr %o1
4001f29c: 40 00 12 ba call 40023d84 <memset>
4001f2a0: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
4001f2a4: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001f2a8: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
4001f2ac: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
4001f2b0: 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;
4001f2b4: 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 );
4001f2b8: 86 00 60 44 add %g1, 0x44, %g3
4001f2bc: 84 00 60 48 add %g1, 0x48, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001f2c0: 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;
4001f2c4: c4 20 60 44 st %g2, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
4001f2c8: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001f2cc: 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 );
4001f2d0: 86 00 60 54 add %g1, 0x54, %g3
4001f2d4: 84 00 60 58 add %g1, 0x58, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001f2d8: 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;
4001f2dc: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
4001f2e0: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001f2e4: 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 );
4001f2e8: 86 00 60 64 add %g1, 0x64, %g3
4001f2ec: 84 00 60 68 add %g1, 0x68, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001f2f0: 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;
4001f2f4: c4 20 60 64 st %g2, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
4001f2f8: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
4001f2fc: 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 );
4001f300: 86 00 60 74 add %g1, 0x74, %g3
4001f304: 84 00 60 78 add %g1, 0x78, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
4001f308: 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;
4001f30c: c4 20 60 74 st %g2, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
4001f310: d2 07 00 00 ld [ %i4 ], %o1
4001f314: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
4001f318: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
4001f31c: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
4001f320: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
4001f324: 7f ff f5 77 call 4001c900 <rtems_rfs_buffer_open>
4001f328: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
4001f32c: ba 92 20 00 orcc %o0, 0, %i5
4001f330: 14 80 00 a9 bg 4001f5d4 <rtems_rfs_fs_open+0x36c> <== NEVER TAKEN
4001f334: 94 10 20 00 clr %o2
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
4001f338: 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;
4001f33c: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
4001f340: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
4001f344: 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);
4001f348: 90 10 00 1b mov %i3, %o0
4001f34c: 92 07 bf cc add %fp, -52, %o1
4001f350: 7f ff f4 b4 call 4001c620 <rtems_rfs_buffer_handle_request>
4001f354: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001f358: ba 92 20 00 orcc %o0, 0, %i5
4001f35c: 04 80 00 1d ble 4001f3d0 <rtems_rfs_fs_open+0x168> <== ALWAYS TAKEN
4001f360: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f364: 7f ff d2 d0 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f368: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f36c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f370: 02 80 00 09 be 4001f394 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4001f374: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
4001f378: 40 00 17 4b call 400250a4 <strerror> <== NOT EXECUTED
4001f37c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f380: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001f384: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f388: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f38c: 40 00 12 fc call 40023f7c <printf> <== NOT EXECUTED
4001f390: 90 12 21 18 or %o0, 0x118, %o0 ! 40037d18 <CSWTCH.2+0x1128><== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
4001f394: 7f ff f6 57 call 4001ccf0 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001f398: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001f39c: 7f ff a2 eb call 40007f48 <free> <== NOT EXECUTED
4001f3a0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f3a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f3a8: 7f ff d2 bf call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f3ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f3b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f3b4: 12 80 00 2c bne 4001f464 <rtems_rfs_fs_open+0x1fc> <== NOT EXECUTED
4001f3b8: 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;
4001f3bc: 40 00 0d 5f call 40022938 <__errno> <== NOT EXECUTED
4001f3c0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001f3c4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
4001f3c8: 81 c7 e0 08 ret <== NOT EXECUTED
4001f3cc: 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);
4001f3d0: c2 07 bf d4 ld [ %fp + -44 ], %g1
4001f3d4: 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)
4001f3d8: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
4001f3dc: c4 0f 40 00 ldub [ %i5 ], %g2
4001f3e0: c8 0f 60 01 ldub [ %i5 + 1 ], %g4
4001f3e4: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
4001f3e8: 83 28 60 08 sll %g1, 8, %g1
4001f3ec: 85 28 a0 18 sll %g2, 0x18, %g2
4001f3f0: 89 29 20 10 sll %g4, 0x10, %g4
4001f3f4: 84 10 80 04 or %g2, %g4, %g2
4001f3f8: 84 10 80 03 or %g2, %g3, %g2
4001f3fc: 84 10 80 01 or %g2, %g1, %g2
4001f400: 03 0a 02 48 sethi %hi(0x28092000), %g1
4001f404: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_SIZE+0x27c92001>
4001f408: 80 a0 80 01 cmp %g2, %g1
4001f40c: 22 80 00 29 be,a 4001f4b0 <rtems_rfs_fs_open+0x248> <== ALWAYS TAKEN
4001f410: c6 0f 60 0d ldub [ %i5 + 0xd ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f414: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f418: 7f ff d2 a3 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f41c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f420: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f424: 32 80 00 1c bne,a 4001f494 <rtems_rfs_fs_open+0x22c> <== NOT EXECUTED
4001f428: 11 10 00 df sethi %hi(0x40037c00), %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);
4001f42c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001f430: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001f434: 7f ff f4 01 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f438: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
4001f43c: 7f ff f6 2d call 4001ccf0 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001f440: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001f444: 7f ff a2 c1 call 40007f48 <free> <== NOT EXECUTED
4001f448: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f44c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f450: 7f ff d2 95 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f454: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f458: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f45c: 02 bf ff d8 be 4001f3bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
4001f460: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
4001f464: 40 00 17 10 call 400250a4 <strerror> <== NOT EXECUTED
4001f468: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f46c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001f470: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f474: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f478: 40 00 12 c1 call 40023f7c <printf> <== NOT EXECUTED
4001f47c: 90 12 23 20 or %o0, 0x320, %o0 ! 40037f20 <CSWTCH.2+0x1330><== NOT EXECUTED
4001f480: 30 bf ff cf b,a 4001f3bc <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);
4001f484: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f488: 40 00 12 bd call 40023f7c <printf> <== NOT EXECUTED
4001f48c: 90 12 20 a0 or %o0, 0xa0, %o0 ! 40037ca0 <CSWTCH.2+0x10b0><== NOT EXECUTED
4001f490: 30 bf ff 7d b,a 4001f284 <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");
4001f494: 40 00 13 52 call 400241dc <puts> <== NOT EXECUTED
4001f498: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
4001f49c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001f4a0: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001f4a4: 7f ff f3 e5 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f4a8: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
4001f4ac: 30 bf ff e4 b,a 4001f43c <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);
4001f4b0: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
4001f4b4: c4 0f 60 0f ldub [ %i5 + 0xf ], %g2
4001f4b8: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
4001f4bc: 87 28 e0 10 sll %g3, 0x10, %g3
4001f4c0: 83 28 60 08 sll %g1, 8, %g1
4001f4c4: 97 2a e0 18 sll %o3, 0x18, %o3
4001f4c8: 96 12 c0 03 or %o3, %g3, %o3
4001f4cc: 96 12 c0 02 or %o3, %g2, %o3
4001f4d0: 96 12 c0 01 or %o3, %g1, %o3
4001f4d4: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
4001f4d8: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
4001f4dc: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
4001f4e0: c4 0f 60 0b ldub [ %i5 + 0xb ], %g2
4001f4e4: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
4001f4e8: 87 28 e0 10 sll %g3, 0x10, %g3
4001f4ec: 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);
4001f4f0: 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;
4001f4f4: 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);
4001f4f8: 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;
4001f4fc: 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);
4001f500: b4 16 80 03 or %i2, %g3, %i2
4001f504: b4 16 80 02 or %i2, %g2, %i2
4001f508: b4 16 80 01 or %i2, %g1, %i2
4001f50c: 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;
4001f510: 40 00 44 dd call 40030884 <__muldi3>
4001f514: 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;
4001f518: 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;
4001f51c: 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;
4001f520: 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;
4001f524: 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;
4001f528: 94 10 20 00 clr %o2
4001f52c: 40 00 44 d6 call 40030884 <__muldi3>
4001f530: 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))
4001f534: 80 a6 00 08 cmp %i0, %o0
4001f538: 38 80 00 3a bgu,a 4001f620 <rtems_rfs_fs_open+0x3b8> <== NEVER TAKEN
4001f53c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f540: 02 80 00 35 be 4001f614 <rtems_rfs_fs_open+0x3ac> <== ALWAYS TAKEN
4001f544: 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)
4001f548: c2 0f 60 24 ldub [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
4001f54c: c8 0f 60 25 ldub [ %i5 + 0x25 ], %g4
4001f550: c6 0f 60 27 ldub [ %i5 + 0x27 ], %g3
4001f554: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
4001f558: 83 28 60 18 sll %g1, 0x18, %g1
4001f55c: 89 29 20 10 sll %g4, 0x10, %g4
4001f560: 85 28 a0 08 sll %g2, 8, %g2
4001f564: 82 10 40 04 or %g1, %g4, %g1
4001f568: 82 10 40 03 or %g1, %g3, %g1
4001f56c: 82 10 40 02 or %g1, %g2, %g1
4001f570: 80 a0 60 38 cmp %g1, 0x38
4001f574: 22 80 00 35 be,a 4001f648 <rtems_rfs_fs_open+0x3e0> <== ALWAYS TAKEN
4001f578: c6 0f 60 13 ldub [ %i5 + 0x13 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f57c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f580: 7f ff d2 49 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f584: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f588: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f58c: 22 bf ff a9 be,a 4001f430 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
4001f590: 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);
4001f594: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
4001f598: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== NOT EXECUTED
4001f59c: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
4001f5a0: c4 0f 60 07 ldub [ %i5 + 7 ], %g2 <== NOT EXECUTED
4001f5a4: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4001f5a8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001f5ac: 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",
4001f5b0: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001f5b4: 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",
4001f5b8: 94 10 20 00 clr %o2 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001f5bc: 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",
4001f5c0: 90 12 21 d0 or %o0, 0x1d0, %o0 <== NOT EXECUTED
4001f5c4: 40 00 12 6e call 40023f7c <printf> <== NOT EXECUTED
4001f5c8: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
4001f5cc: 10 bf ff 99 b 4001f430 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
4001f5d0: 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);
4001f5d4: 7f ff a2 5d call 40007f48 <free> <== NOT EXECUTED
4001f5d8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f5dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f5e0: 7f ff d2 31 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f5e4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f5e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f5ec: 02 bf ff 74 be 4001f3bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
4001f5f0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
4001f5f4: 40 00 16 ac call 400250a4 <strerror> <== NOT EXECUTED
4001f5f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f5fc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001f600: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f604: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f608: 40 00 12 5d call 40023f7c <printf> <== NOT EXECUTED
4001f60c: 90 12 20 e8 or %o0, 0xe8, %o0 ! 40037ce8 <CSWTCH.2+0x10f8><== NOT EXECUTED
4001f610: 30 bf ff 6b b,a 4001f3bc <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))
4001f614: 28 bf ff ce bleu,a 4001f54c <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
4001f618: c2 0f 60 24 ldub [ %i5 + 0x24 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f61c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f620: 7f ff d2 21 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f624: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f628: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f62c: 22 bf ff 81 be,a 4001f430 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
4001f630: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
4001f634: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f638: 40 00 12 e9 call 400241dc <puts> <== NOT EXECUTED
4001f63c: 90 12 21 90 or %o0, 0x190, %o0 ! 40037d90 <CSWTCH.2+0x11a0><== NOT EXECUTED
4001f640: 10 bf ff 7c b 4001f430 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
4001f644: 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);
4001f648: c2 0f 60 10 ldub [ %i5 + 0x10 ], %g1
4001f64c: c8 0f 60 11 ldub [ %i5 + 0x11 ], %g4
4001f650: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
4001f654: 89 29 20 10 sll %g4, 0x10, %g4
4001f658: 85 28 a0 08 sll %g2, 8, %g2
4001f65c: 83 28 60 18 sll %g1, 0x18, %g1
4001f660: 82 10 40 04 or %g1, %g4, %g1
4001f664: 82 10 40 03 or %g1, %g3, %g1
4001f668: 82 10 40 02 or %g1, %g2, %g1
4001f66c: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
4001f670: c6 0f 60 17 ldub [ %i5 + 0x17 ], %g3
4001f674: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
4001f678: c8 0f 60 15 ldub [ %i5 + 0x15 ], %g4
4001f67c: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
4001f680: 89 29 20 10 sll %g4, 0x10, %g4
4001f684: 85 28 a0 08 sll %g2, 8, %g2
4001f688: 83 28 60 18 sll %g1, 0x18, %g1
4001f68c: 82 10 40 04 or %g1, %g4, %g1
4001f690: 82 10 40 03 or %g1, %g3, %g1
4001f694: 82 10 40 02 or %g1, %g2, %g1
4001f698: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
4001f69c: c6 0f 60 19 ldub [ %i5 + 0x19 ], %g3
4001f6a0: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
4001f6a4: c4 0f 60 1b ldub [ %i5 + 0x1b ], %g2
4001f6a8: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
4001f6ac: 87 28 e0 10 sll %g3, 0x10, %g3
4001f6b0: 83 28 60 08 sll %g1, 8, %g1
4001f6b4: b1 2e 20 18 sll %i0, 0x18, %i0
4001f6b8: b0 16 00 03 or %i0, %g3, %i0
4001f6bc: b0 16 00 02 or %i0, %g2, %i0
4001f6c0: b0 16 00 01 or %i0, %g1, %i0
4001f6c4: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
4001f6c8: c4 0f 60 1f ldub [ %i5 + 0x1f ], %g2
4001f6cc: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
4001f6d0: c6 0f 60 1d ldub [ %i5 + 0x1d ], %g3
4001f6d4: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
4001f6d8: 87 28 e0 10 sll %g3, 0x10, %g3
4001f6dc: 83 28 60 08 sll %g1, 8, %g1
4001f6e0: b3 2e 60 18 sll %i1, 0x18, %i1
4001f6e4: b2 16 40 03 or %i1, %g3, %i1
4001f6e8: b2 16 40 02 or %i1, %g2, %i1
4001f6ec: b2 16 40 01 or %i1, %g1, %i1
4001f6f0: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4001f6f4: c4 0f 60 21 ldub [ %i5 + 0x21 ], %g2
4001f6f8: de 0f 60 20 ldub [ %i5 + 0x20 ], %o7
4001f6fc: c6 0f 60 22 ldub [ %i5 + 0x22 ], %g3
4001f700: c8 0f 60 23 ldub [ %i5 + 0x23 ], %g4
4001f704: 85 28 a0 10 sll %g2, 0x10, %g2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
4001f708: 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);
4001f70c: bb 2b e0 18 sll %o7, 0x18, %i5
4001f710: 87 28 e0 08 sll %g3, 8, %g3
4001f714: 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;
4001f718: 85 28 60 02 sll %g1, 2, %g2
4001f71c: 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);
4001f720: 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;
4001f724: 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);
4001f728: 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 =
4001f72c: 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;
4001f730: 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 =
4001f734: 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;
4001f738: 7f ff 8b a0 call 400025b8 <.umul>
4001f73c: fa 26 e0 2c st %i5, [ %i3 + 0x2c ]
4001f740: 83 2a 20 02 sll %o0, 2, %g1
4001f744: 82 00 40 08 add %g1, %o0, %g1
fs->inodes = fs->group_count * fs->group_inodes;
4001f748: 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 =
4001f74c: 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;
4001f750: 7f ff 8b 9a call 400025b8 <.umul>
4001f754: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001f758: 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;
4001f75c: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4001f760: 7f ff 8b d0 call 400026a0 <.udiv>
4001f764: 90 10 00 1a mov %i2, %o0
4001f768: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
4001f76c: b5 2e a0 03 sll %i2, 3, %i2
4001f770: 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 >
4001f774: 80 a6 40 1a cmp %i1, %i2
4001f778: 08 80 00 10 bleu 4001f7b8 <rtems_rfs_fs_open+0x550> <== ALWAYS TAKEN
4001f77c: 90 10 00 1b mov %i3, %o0
4001f780: 7f ff f3 2e call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f784: 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))
4001f788: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f78c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
4001f790: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
4001f794: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
4001f798: 7f ff d1 c3 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f79c: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
4001f7a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f7a4: 02 bf fe fc be 4001f394 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4001f7a8: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
4001f7ac: 40 00 12 8c call 400241dc <puts> <== NOT EXECUTED
4001f7b0: 90 12 22 18 or %o0, 0x218, %o0 ! 40037e18 <CSWTCH.2+0x1228><== NOT EXECUTED
4001f7b4: 30 bf fe f8 b,a 4001f394 <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);
4001f7b8: 7f ff f3 20 call 4001c438 <rtems_rfs_buffer_handle_release>
4001f7bc: 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));
4001f7c0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
handle->dirty = false;
4001f7c4: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
4001f7c8: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
4001f7cc: c0 27 bf d4 clr [ %fp + -44 ]
4001f7d0: 7f ff f4 ff call 4001cbcc <rtems_rfs_buffer_setblksize>
4001f7d4: 90 10 00 1b mov %i3, %o0
if (rc > 0)
4001f7d8: ba 92 20 00 orcc %o0, 0, %i5
4001f7dc: 04 80 00 23 ble 4001f868 <rtems_rfs_fs_open+0x600> <== ALWAYS TAKEN
4001f7e0: 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);
4001f7e4: 7f ff f3 15 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f7e8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001f7ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f7f0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
4001f7f4: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
4001f7f8: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
4001f7fc: 7f ff d1 aa call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f800: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
4001f804: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f808: 02 bf fe e3 be 4001f394 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4001f80c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
4001f810: 40 00 16 25 call 400250a4 <strerror> <== NOT EXECUTED
4001f814: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f818: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001f81c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f820: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f824: 40 00 11 d6 call 40023f7c <printf> <== NOT EXECUTED
4001f828: 90 12 22 60 or %o0, 0x260, %o0 ! 40037e60 <CSWTCH.2+0x1270><== NOT EXECUTED
4001f82c: 30 bf fe da b,a 4001f394 <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))
4001f830: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f834: 7f ff d1 9c call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f838: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001f83c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f840: 02 80 00 04 be 4001f850 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
4001f844: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
4001f848: 40 00 12 65 call 400241dc <puts> <== NOT EXECUTED
4001f84c: 90 12 20 b8 or %o0, 0xb8, %o0 ! 40037cb8 <CSWTCH.2+0x10c8><== NOT EXECUTED
errno = ENOMEM;
4001f850: 40 00 0c 3a call 40022938 <__errno> <== NOT EXECUTED
4001f854: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001f858: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4001f85c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001f860: 81 c7 e0 08 ret <== NOT EXECUTED
4001f864: 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));
4001f868: fa 06 e0 24 ld [ %i3 + 0x24 ], %i5
4001f86c: 92 10 20 50 mov 0x50, %o1
4001f870: 7f ff a1 53 call 40007dbc <calloc>
4001f874: 90 10 00 1d mov %i5, %o0
if (!fs->groups)
4001f878: 80 a2 20 00 cmp %o0, 0
4001f87c: 02 80 00 97 be 4001fad8 <rtems_rfs_fs_open+0x870> <== NEVER TAKEN
4001f880: 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++)
4001f884: b2 10 20 00 clr %i1
4001f888: 80 a7 60 00 cmp %i5, 0
4001f88c: 14 80 00 08 bg 4001f8ac <rtems_rfs_fs_open+0x644> <== ALWAYS TAKEN
4001f890: 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);
4001f894: 10 80 00 35 b 4001f968 <rtems_rfs_fs_open+0x700> <== NOT EXECUTED
4001f898: 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++)
4001f89c: b4 06 a0 01 inc %i2
4001f8a0: 80 a6 80 01 cmp %i2, %g1
4001f8a4: 16 80 00 30 bge 4001f964 <rtems_rfs_fs_open+0x6fc> <== ALWAYS TAKEN
4001f8a8: b2 06 60 50 add %i1, 0x50, %i1
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
4001f8ac: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5
4001f8b0: 90 10 00 1a mov %i2, %o0
4001f8b4: 7f ff 8b 41 call 400025b8 <.umul>
4001f8b8: 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,
4001f8bc: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
4001f8c0: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
4001f8c4: 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,
4001f8c8: 94 10 00 1d mov %i5, %o2
4001f8cc: 98 03 00 19 add %o4, %i1, %o4
4001f8d0: 7f ff c8 99 call 40011b34 <rtems_rfs_group_open>
4001f8d4: 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)
4001f8d8: ba 92 20 00 orcc %o0, 0, %i5
4001f8dc: 24 bf ff f0 ble,a 4001f89c <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
4001f8e0: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
{
int g;
for (g = 0; g < group; g++)
4001f8e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001f8e8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001f8ec: 02 80 00 0a be 4001f914 <rtems_rfs_fs_open+0x6ac> <== NOT EXECUTED
4001f8f0: b2 10 20 00 clr %i1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
4001f8f4: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1 <== NOT EXECUTED
4001f8f8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001f8fc: 7f ff c9 1b call 40011d68 <rtems_rfs_group_close> <== NOT EXECUTED
4001f900: 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++)
4001f904: b2 06 60 01 inc %i1 <== NOT EXECUTED
4001f908: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
4001f90c: 12 bf ff fa bne 4001f8f4 <rtems_rfs_fs_open+0x68c> <== NOT EXECUTED
4001f910: 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);
4001f914: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001f918: 7f ff f2 c8 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f91c: 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))
4001f920: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f924: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
4001f928: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
4001f92c: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
4001f930: 7f ff d1 5d call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001f934: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
4001f938: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f93c: 02 bf fe 96 be 4001f394 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4001f940: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
4001f944: 40 00 15 d8 call 400250a4 <strerror> <== NOT EXECUTED
4001f948: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f94c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001f950: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f954: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001f958: 40 00 11 89 call 40023f7c <printf> <== NOT EXECUTED
4001f95c: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40037ee0 <CSWTCH.2+0x12f0><== NOT EXECUTED
4001f960: 30 bf fe 8d b,a 4001f394 <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);
4001f964: d0 07 00 00 ld [ %i4 ], %o0
4001f968: 92 10 20 01 mov 1, %o1
4001f96c: 94 07 bf d8 add %fp, -40, %o2
4001f970: 7f ff ca a6 call 40012408 <rtems_rfs_inode_open>
4001f974: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001f978: ba 92 20 00 orcc %o0, 0, %i5
4001f97c: 14 80 00 45 bg 4001fa90 <rtems_rfs_fs_open+0x828> <== NEVER TAKEN
4001f980: 01 00 00 00 nop
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
4001f984: d0 07 00 00 ld [ %i4 ], %o0
4001f988: c2 02 00 00 ld [ %o0 ], %g1
4001f98c: 80 88 60 04 btst 4, %g1
4001f990: 12 80 00 10 bne 4001f9d0 <rtems_rfs_fs_open+0x768>
4001f994: 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);
4001f998: c4 08 60 03 ldub [ %g1 + 3 ], %g2
4001f99c: c6 08 60 02 ldub [ %g1 + 2 ], %g3
4001f9a0: 83 28 e0 08 sll %g3, 8, %g1
4001f9a4: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
4001f9a8: 05 3f ff c0 sethi %hi(0xffff0000), %g2
4001f9ac: 87 28 60 10 sll %g1, 0x10, %g3
4001f9b0: 80 a0 c0 02 cmp %g3, %g2
4001f9b4: 02 80 00 23 be 4001fa40 <rtems_rfs_fs_open+0x7d8> <== NEVER TAKEN
4001f9b8: 05 00 00 3c sethi %hi(0xf000), %g2
4001f9bc: 82 08 40 02 and %g1, %g2, %g1
4001f9c0: 05 00 00 10 sethi %hi(0x4000), %g2
4001f9c4: 80 a0 40 02 cmp %g1, %g2
4001f9c8: 12 80 00 1e bne 4001fa40 <rtems_rfs_fs_open+0x7d8> <== NEVER TAKEN
4001f9cc: 01 00 00 00 nop
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
4001f9d0: 7f ff cb 06 call 400125e8 <rtems_rfs_inode_close>
4001f9d4: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001f9d8: ba 92 20 00 orcc %o0, 0, %i5
4001f9dc: 14 80 00 07 bg 4001f9f8 <rtems_rfs_fs_open+0x790> <== NEVER TAKEN
4001f9e0: 01 00 00 00 nop
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
4001f9e4: 40 00 0b d5 call 40022938 <__errno>
4001f9e8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4001f9ec: c0 22 00 00 clr [ %o0 ]
4001f9f0: 81 c7 e0 08 ret
4001f9f4: 81 e8 00 00 restore
}
rc = rtems_rfs_inode_close (*fs, &inode);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
4001f9f8: 7f ff f4 be call 4001ccf0 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001f9fc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001fa00: 7f ff a1 52 call 40007f48 <free> <== NOT EXECUTED
4001fa04: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001fa08: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001fa0c: 7f ff d1 26 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fa10: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001fa14: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fa18: 02 bf fe 69 be 4001f3bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
4001fa1c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
4001fa20: 40 00 15 a1 call 400250a4 <strerror> <== NOT EXECUTED
4001fa24: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001fa28: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001fa2c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001fa30: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001fa34: 40 00 11 52 call 40023f7c <printf> <== NOT EXECUTED
4001fa38: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 40037fb0 <CSWTCH.2+0x13c0><== NOT EXECUTED
4001fa3c: 30 bf fe 60 b,a 4001f3bc <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);
4001fa40: 7f ff ca ea call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fa44: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
4001fa48: 7f ff f4 aa call 4001ccf0 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001fa4c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001fa50: 7f ff a1 3e call 40007f48 <free> <== NOT EXECUTED
4001fa54: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001fa58: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001fa5c: 7f ff d1 12 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fa60: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001fa64: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fa68: 02 80 00 04 be 4001fa78 <rtems_rfs_fs_open+0x810> <== NOT EXECUTED
4001fa6c: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
4001fa70: 40 00 11 db call 400241dc <puts> <== NOT EXECUTED
4001fa74: 90 12 23 80 or %o0, 0x380, %o0 ! 40037f80 <CSWTCH.2+0x1390><== NOT EXECUTED
errno = EIO;
4001fa78: 40 00 0b b0 call 40022938 <__errno> <== NOT EXECUTED
4001fa7c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001fa80: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001fa84: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001fa88: 81 c7 e0 08 ret <== NOT EXECUTED
4001fa8c: 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);
4001fa90: 7f ff f4 98 call 4001ccf0 <rtems_rfs_buffer_close> <== NOT EXECUTED
4001fa94: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4001fa98: 7f ff a1 2c call 40007f48 <free> <== NOT EXECUTED
4001fa9c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4001faa0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001faa4: 7f ff d1 00 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001faa8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4001faac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fab0: 02 bf fe 43 be 4001f3bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
4001fab4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
4001fab8: 40 00 15 7b call 400250a4 <strerror> <== NOT EXECUTED
4001fabc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001fac0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001fac4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001fac8: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001facc: 40 00 11 2c call 40023f7c <printf> <== NOT EXECUTED
4001fad0: 90 12 23 50 or %o0, 0x350, %o0 ! 40037f50 <CSWTCH.2+0x1360><== NOT EXECUTED
4001fad4: 30 bf fe 3a b,a 4001f3bc <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);
4001fad8: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
4001fadc: 7f ff f2 57 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001fae0: 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))
4001fae4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001fae8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
4001faec: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
4001faf0: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
handle->buffer = NULL;
4001faf4: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
4001faf8: 7f ff d0 eb call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fafc: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
4001fb00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fb04: 02 bf fe 24 be 4001f394 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4001fb08: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
4001fb0c: 40 00 11 b4 call 400241dc <puts> <== NOT EXECUTED
4001fb10: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 40037ea8 <CSWTCH.2+0x12b8><== NOT EXECUTED
4001fb14: 30 bf fe 20 b,a 4001f394 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4001f21c <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)
{
4001f21c: 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;
4001f220: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
4001f224: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
4001f228: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001f22c: 40 00 45 96 call 40030884 <__muldi3> <== NOT EXECUTED
4001f230: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
4001f234: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4001f238: 81 c7 e0 08 ret <== NOT EXECUTED
4001f23c: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
40011e14 <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)
{
40011e14: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40011e18: 80 a6 a0 00 cmp %i2, 0
40011e1c: 22 80 00 04 be,a 40011e2c <rtems_rfs_group_bitmap_alloc+0x18>
40011e20: e6 06 20 28 ld [ %i0 + 0x28 ], %l3
{
size = fs->group_inodes;
40011e24: e6 06 20 2c ld [ %i0 + 0x2c ], %l3
goal -= RTEMS_RFS_ROOT_INO;
40011e28: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
group_start = goal / size;
40011e2c: 90 10 00 19 mov %i1, %o0
40011e30: 7f ff c2 1c call 400026a0 <.udiv>
40011e34: 92 10 00 13 mov %l3, %o1
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011e38: 92 10 00 13 mov %l3, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
40011e3c: a2 10 00 08 mov %o0, %l1
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
40011e40: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011e44: 90 10 00 19 mov %i1, %o0
40011e48: 40 00 79 e3 call 400305d4 <.urem>
40011e4c: ba 10 00 11 mov %l1, %i5
offset = 0;
updown = true;
40011e50: a0 10 20 01 mov 1, %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40011e54: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40011e58: 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;
40011e5c: 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))
40011e60: 80 a7 60 00 cmp %i5, 0
40011e64: 06 80 00 32 bl 40011f2c <rtems_rfs_group_bitmap_alloc+0x118><== NEVER TAKEN
40011e68: 80 8c 20 ff btst 0xff, %l0
40011e6c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40011e70: 80 a0 40 1d cmp %g1, %i5
40011e74: 04 80 00 2e ble 40011f2c <rtems_rfs_group_bitmap_alloc+0x118>
40011e78: 80 8c 20 ff btst 0xff, %l0
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
40011e7c: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
40011e80: ab 2f 60 04 sll %i5, 4, %l5
40011e84: a9 2f 60 06 sll %i5, 6, %l4
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
40011e88: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
40011e8c: 82 05 40 14 add %l5, %l4, %g1
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
40011e90: 02 80 00 46 be 40011fa8 <rtems_rfs_group_bitmap_alloc+0x194>
40011e94: a4 04 80 01 add %l2, %g1, %l2
bitmap = &fs->groups[group].inode_bitmap;
40011e98: 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);
40011e9c: d2 07 bf fc ld [ %fp + -4 ], %o1
40011ea0: 90 10 00 12 mov %l2, %o0
40011ea4: 94 07 bf fb add %fp, -5, %o2
40011ea8: 40 00 24 54 call 4001aff8 <rtems_rfs_bitmap_map_alloc>
40011eac: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
40011eb0: 80 a2 20 00 cmp %o0, 0
40011eb4: 14 80 00 3b bg 40011fa0 <rtems_rfs_group_bitmap_alloc+0x18c><== NEVER TAKEN
40011eb8: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
40011ebc: c2 06 00 00 ld [ %i0 ], %g1
40011ec0: 80 88 60 01 btst 1, %g1
40011ec4: 22 80 00 3b be,a 40011fb0 <rtems_rfs_group_bitmap_alloc+0x19c><== ALWAYS TAKEN
40011ec8: d2 04 80 00 ld [ %l2 ], %o1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
40011ecc: c2 0f bf fb ldub [ %fp + -5 ], %g1 <== NOT EXECUTED
40011ed0: 80 a0 60 00 cmp %g1, 0
40011ed4: 12 80 00 3b bne 40011fc0 <rtems_rfs_group_bitmap_alloc+0x1ac>
40011ed8: 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)
40011edc: 22 80 00 07 be,a 40011ef8 <rtems_rfs_group_bitmap_alloc+0xe4><== NEVER TAKEN
40011ee0: b2 06 60 01 inc %i1 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40011ee4: 80 a7 20 00 cmp %i4, 0
40011ee8: 04 80 00 03 ble 40011ef4 <rtems_rfs_group_bitmap_alloc+0xe0><== NEVER TAKEN
40011eec: b8 10 20 01 mov 1, %i4
40011ef0: b8 10 3f ff mov -1, %i4
offset++;
40011ef4: b2 06 60 01 inc %i1
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40011ef8: 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);
40011efc: 90 10 00 1c mov %i4, %o0
40011f00: 7f ff c1 ae call 400025b8 <.umul>
40011f04: 92 10 00 19 mov %i1, %o1
if (offset)
bit = direction > 0 ? 0 : size - 1;
40011f08: 82 10 20 00 clr %g1
40011f0c: 80 a7 20 00 cmp %i4, 0
40011f10: 04 80 00 17 ble 40011f6c <rtems_rfs_group_bitmap_alloc+0x158><== ALWAYS TAKEN
40011f14: ba 02 00 11 add %o0, %l1, %i5
40011f18: 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))
40011f1c: 80 a7 60 00 cmp %i5, 0
40011f20: 36 bf ff d4 bge,a 40011e70 <rtems_rfs_group_bitmap_alloc+0x5c>
40011f24: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
if (!updown)
40011f28: 80 8c 20 ff btst 0xff, %l0
40011f2c: 02 80 00 13 be 40011f78 <rtems_rfs_group_bitmap_alloc+0x164>
40011f30: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
40011f34: 04 80 00 03 ble 40011f40 <rtems_rfs_group_bitmap_alloc+0x12c><== ALWAYS TAKEN
40011f38: b8 10 20 01 mov 1, %i4
40011f3c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40011f40: 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);
40011f44: 90 10 00 1c mov %i4, %o0
40011f48: 7f ff c1 9c call 400025b8 <.umul>
40011f4c: 92 10 00 19 mov %i1, %o1
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
updown = false;
40011f50: 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)
40011f54: 80 a6 60 00 cmp %i1, 0
40011f58: 02 bf ff c2 be 40011e60 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
40011f5c: ba 02 00 11 add %o0, %l1, %i5
bit = direction > 0 ? 0 : size - 1;
40011f60: 80 a7 20 00 cmp %i4, 0
40011f64: 14 bf ff ed bg 40011f18 <rtems_rfs_group_bitmap_alloc+0x104><== ALWAYS TAKEN
40011f68: 82 10 20 00 clr %g1
40011f6c: 82 04 ff ff add %l3, -1, %g1
40011f70: 10 bf ff eb b 40011f1c <rtems_rfs_group_bitmap_alloc+0x108>
40011f74: c2 27 bf fc st %g1, [ %fp + -4 ]
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011f78: 90 10 20 00 clr %o0
40011f7c: 40 00 07 ca call 40013ea4 <rtems_rfs_trace>
40011f80: 13 00 00 80 sethi %hi(0x20000), %o1
40011f84: 80 8a 20 ff btst 0xff, %o0
40011f88: 22 80 00 06 be,a 40011fa0 <rtems_rfs_group_bitmap_alloc+0x18c><== ALWAYS TAKEN
40011f8c: 90 10 20 1c mov 0x1c, %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
40011f90: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40011f94: 40 00 48 92 call 400241dc <puts> <== NOT EXECUTED
40011f98: 90 12 20 b8 or %o0, 0xb8, %o0 ! 40035cb8 <_CPU_Trap_slot_template+0x9d0><== NOT EXECUTED
return ENOSPC;
40011f9c: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
}
40011fa0: 81 c7 e0 08 ret
40011fa4: 91 e8 00 08 restore %g0, %o0, %o0
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
40011fa8: 10 bf ff bd b 40011e9c <rtems_rfs_group_bitmap_alloc+0x88>
40011fac: 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);
40011fb0: 40 00 29 22 call 4001c438 <rtems_rfs_buffer_handle_release>
40011fb4: 90 10 00 18 mov %i0, %o0
if (allocated)
40011fb8: 10 bf ff c6 b 40011ed0 <rtems_rfs_group_bitmap_alloc+0xbc>
40011fbc: c2 0f bf fb ldub [ %fp + -5 ], %g1
{
if (inode)
40011fc0: 80 a6 a0 00 cmp %i2, 0
40011fc4: 32 80 00 15 bne,a 40012018 <rtems_rfs_group_bitmap_alloc+0x204>
40011fc8: 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);
40011fcc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40011fd0: c4 07 bf fc ld [ %fp + -4 ], %g2
40011fd4: a8 05 40 14 add %l5, %l4, %l4
40011fd8: c2 00 40 14 ld [ %g1 + %l4 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011fdc: 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);
40011fe0: 82 00 80 01 add %g2, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40011fe4: 13 00 00 80 sethi %hi(0x20000), %o1
40011fe8: 40 00 07 af call 40013ea4 <rtems_rfs_trace>
40011fec: c2 26 c0 00 st %g1, [ %i3 ]
40011ff0: 80 8a 20 ff btst 0xff, %o0
40011ff4: 02 80 00 07 be 40012010 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
40011ff8: 13 10 00 d7 sethi %hi(0x40035c00), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40011ffc: 92 12 60 78 or %o1, 0x78, %o1 ! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40012000: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
40012004: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40012008: 40 00 47 dd call 40023f7c <printf> <== NOT EXECUTED
4001200c: 90 12 20 80 or %o0, 0x80, %o0 ! 40035c80 <_CPU_Trap_slot_template+0x998><== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
40012010: 10 bf ff e4 b 40011fa0 <rtems_rfs_group_bitmap_alloc+0x18c>
40012014: 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);
40012018: 90 10 00 1d mov %i5, %o0
4001201c: 7f ff c1 67 call 400025b8 <.umul>
40012020: fa 07 bf fc ld [ %fp + -4 ], %i5
40012024: 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))
40012028: 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);
4001202c: 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))
40012030: 90 10 20 00 clr %o0
40012034: 40 00 07 9c call 40013ea4 <rtems_rfs_trace>
40012038: fa 26 c0 00 st %i5, [ %i3 ]
4001203c: 80 8a 20 ff btst 0xff, %o0
40012040: 02 bf ff f4 be 40012010 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
40012044: 13 10 00 d7 sethi %hi(0x40035c00), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40012048: 10 bf ff ee b 40012000 <rtems_rfs_group_bitmap_alloc+0x1ec><== NOT EXECUTED
4001204c: 92 12 60 70 or %o1, 0x70, %o1 ! 40035c70 <_CPU_Trap_slot_template+0x988><== NOT EXECUTED
40012050 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
40012050: 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))
40012054: 90 10 20 00 clr %o0
40012058: 13 00 00 80 sethi %hi(0x20000), %o1
4001205c: 40 00 07 92 call 40013ea4 <rtems_rfs_trace>
40012060: ba 10 00 18 mov %i0, %i5
40012064: 80 8a 20 ff btst 0xff, %o0
40012068: 02 80 00 0b be 40012094 <rtems_rfs_group_bitmap_free+0x44><== ALWAYS TAKEN
4001206c: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40012070: 12 80 00 3a bne 40012158 <rtems_rfs_group_bitmap_free+0x108><== NOT EXECUTED
40012074: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
40012078: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
4001207c: 92 12 60 78 or %o1, 0x78, %o1 ! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40012080: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40012084: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40012088: 40 00 47 bd call 40023f7c <printf> <== NOT EXECUTED
4001208c: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40012090: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40012094: 22 80 00 1a be,a 400120fc <rtems_rfs_group_bitmap_free+0xac>
40012098: f8 07 60 28 ld [ %i5 + 0x28 ], %i4
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
4001209c: 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;
400120a0: 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);
400120a4: 92 10 00 1c mov %i4, %o1
400120a8: 40 00 79 4b call 400305d4 <.urem>
400120ac: 90 10 00 1a mov %i2, %o0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
400120b0: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
400120b4: b6 10 00 08 mov %o0, %i3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
400120b8: 7f ff c1 7a call 400026a0 <.udiv>
400120bc: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
400120c0: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
400120c4: 83 2a 20 04 sll %o0, 4, %g1
400120c8: 91 2a 20 06 sll %o0, 6, %o0
400120cc: 90 00 40 08 add %g1, %o0, %o0
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400120d0: 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;
400120d4: b8 07 00 08 add %i4, %o0, %i4
400120d8: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400120dc: 40 00 23 33 call 4001ada8 <rtems_rfs_bitmap_map_clear>
400120e0: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400120e4: 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);
400120e8: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400120ec: 40 00 28 d3 call 4001c438 <rtems_rfs_buffer_handle_release>
400120f0: 90 10 00 1d mov %i5, %o0
return rc;
}
400120f4: 81 c7 e0 08 ret
400120f8: 81 e8 00 00 restore
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
400120fc: b4 06 bf ff add %i2, -1, %i2
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
40012100: 92 10 00 1c mov %i4, %o1
40012104: 40 00 79 34 call 400305d4 <.urem>
40012108: 90 10 00 1a mov %i2, %o0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
4001210c: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
40012110: b6 10 00 08 mov %o0, %i3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
40012114: 7f ff c1 63 call 400026a0 <.udiv>
40012118: 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;
4001211c: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
40012120: 83 2a 20 04 sll %o0, 4, %g1
40012124: 91 2a 20 06 sll %o0, 6, %o0
40012128: 90 00 40 08 add %g1, %o0, %o0
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
4001212c: 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;
40012130: b8 07 00 08 add %i4, %o0, %i4
40012134: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40012138: 40 00 23 1c call 4001ada8 <rtems_rfs_bitmap_map_clear>
4001213c: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40012140: 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);
40012144: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40012148: 40 00 28 bc call 4001c438 <rtems_rfs_buffer_handle_release>
4001214c: 90 10 00 1d mov %i5, %o0
return rc;
}
40012150: 81 c7 e0 08 ret
40012154: 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",
40012158: 10 bf ff ca b 40012080 <rtems_rfs_group_bitmap_free+0x30> <== NOT EXECUTED
4001215c: 92 12 60 70 or %o1, 0x70, %o1 <== NOT EXECUTED
40012160 <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)
{
40012160: 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))
40012164: 90 10 20 00 clr %o0 <== NOT EXECUTED
40012168: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
4001216c: 40 00 07 4e call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40012170: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
40012174: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012178: 02 80 00 0b be 400121a4 <rtems_rfs_group_bitmap_test+0x44><== NOT EXECUTED
4001217c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
40012180: 12 80 00 2f bne 4001223c <rtems_rfs_group_bitmap_test+0xdc><== NOT EXECUTED
40012184: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
40012188: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
4001218c: 92 12 60 78 or %o1, 0x78, %o1 ! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40012190: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40012194: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40012198: 40 00 47 79 call 40023f7c <printf> <== NOT EXECUTED
4001219c: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
400121a0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400121a4: 22 80 00 0b be,a 400121d0 <rtems_rfs_group_bitmap_test+0x70><== NOT EXECUTED
400121a8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
400121ac: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400121b0: 04 80 00 06 ble 400121c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400121b4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
400121b8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
400121bc: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
400121c0: 28 80 00 21 bleu,a 40012244 <rtems_rfs_group_bitmap_test+0xe4><== NOT EXECUTED
400121c4: 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;
}
400121c8: 81 c7 e0 08 ret <== NOT EXECUTED
400121cc: 81 e8 00 00 restore <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
400121d0: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
400121d4: 1a bf ff fd bcc 400121c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400121d8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
400121dc: f8 07 60 28 ld [ %i5 + 0x28 ], %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
400121e0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400121e4: 40 00 78 fc call 400305d4 <.urem> <== NOT EXECUTED
400121e8: 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;
400121ec: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
400121f0: 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;
400121f4: 7f ff c1 2b call 400026a0 <.udiv> <== NOT EXECUTED
400121f8: 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;
400121fc: f8 07 60 20 ld [ %i5 + 0x20 ], %i4 <== NOT EXECUTED
40012200: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED
40012204: 91 2a 20 06 sll %o0, 6, %o0 <== NOT EXECUTED
40012208: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
4001220c: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
40012210: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
40012214: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40012218: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001221c: 40 00 23 06 call 4001ae34 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
40012220: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40012224: 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);
40012228: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4001222c: 40 00 28 83 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012230: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
40012234: 81 c7 e0 08 ret <== NOT EXECUTED
40012238: 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",
4001223c: 10 bf ff d5 b 40012190 <rtems_rfs_group_bitmap_test+0x30> <== NOT EXECUTED
40012240: 92 12 60 70 or %o1, 0x70, %o1 <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
40012244: 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);
40012248: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001224c: 40 00 78 e2 call 400305d4 <.urem> <== NOT EXECUTED
40012250: 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;
40012254: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
40012258: 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;
4001225c: 7f ff c1 11 call 400026a0 <.udiv> <== NOT EXECUTED
40012260: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
40012264: f8 07 60 20 ld [ %i5 + 0x20 ], %i4 <== NOT EXECUTED
40012268: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED
4001226c: 91 2a 20 06 sll %o0, 6, %o0 <== NOT EXECUTED
40012270: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
40012274: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
40012278: 10 bf ff e7 b 40012214 <rtems_rfs_group_bitmap_test+0xb4> <== NOT EXECUTED
4001227c: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
40011d68 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40011d68: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
40011d6c: 90 10 20 00 clr %o0
40011d70: 13 00 00 40 sethi %hi(0x10000), %o1
40011d74: 40 00 08 4c call 40013ea4 <rtems_rfs_trace>
40011d78: ba 10 00 18 mov %i0, %i5
40011d7c: 80 8a 20 ff btst 0xff, %o0
40011d80: 32 80 00 17 bne,a 40011ddc <rtems_rfs_group_close+0x74> <== NEVER TAKEN
40011d84: 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);
40011d88: 40 00 25 24 call 4001b218 <rtems_rfs_bitmap_close>
40011d8c: 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);
40011d90: 92 06 60 44 add %i1, 0x44, %o1
40011d94: b8 10 00 08 mov %o0, %i4
40011d98: 40 00 29 a8 call 4001c438 <rtems_rfs_buffer_handle_release>
40011d9c: 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);
40011da0: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
40011da4: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
40011da8: c0 26 60 48 clr [ %i1 + 0x48 ]
40011dac: 40 00 25 1b call 4001b218 <rtems_rfs_bitmap_close>
40011db0: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
40011db4: b0 92 20 00 orcc %o0, 0, %i0
40011db8: 04 80 00 0d ble 40011dec <rtems_rfs_group_close+0x84> <== ALWAYS TAKEN
40011dbc: 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);
40011dc0: 40 00 29 9e call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011dc4: 92 06 60 20 add %i1, 0x20, %o1 <== NOT EXECUTED
handle->dirty = false;
40011dc8: c0 2e 60 20 clrb [ %i1 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40011dcc: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
40011dd0: 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;
}
40011dd4: 81 c7 e0 08 ret <== NOT EXECUTED
40011dd8: 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);
40011ddc: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40011de0: 40 00 48 67 call 40023f7c <printf> <== NOT EXECUTED
40011de4: 90 12 20 48 or %o0, 0x48, %o0 ! 40035c48 <_CPU_Trap_slot_template+0x960><== NOT EXECUTED
40011de8: 30 bf ff e8 b,a 40011d88 <rtems_rfs_group_close+0x20> <== NOT EXECUTED
40011dec: 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);
40011df0: 92 06 60 20 add %i1, 0x20, %o1
40011df4: 40 00 29 91 call 4001c438 <rtems_rfs_buffer_handle_release>
40011df8: b1 3e 20 1f sra %i0, 0x1f, %i0
40011dfc: b0 0f 00 18 and %i4, %i0, %i0
handle->dirty = false;
40011e00: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40011e04: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
40011e08: 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;
}
40011e0c: 81 c7 e0 08 ret
40011e10: 81 e8 00 00 restore
40011b34 <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)
{
40011b34: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40011b38: c2 06 20 04 ld [ %i0 + 4 ], %g1
40011b3c: 80 a0 40 19 cmp %g1, %i1
40011b40: 08 80 00 44 bleu 40011c50 <rtems_rfs_group_open+0x11c> <== NEVER TAKEN
40011b44: 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))
40011b48: 84 06 80 19 add %i2, %i1, %g2
40011b4c: 80 a0 40 02 cmp %g1, %g2
40011b50: 28 80 00 02 bleu,a 40011b58 <rtems_rfs_group_open+0x24> <== ALWAYS TAKEN
40011b54: b4 20 40 19 sub %g1, %i1, %i2
40011b58: 80 a6 80 1b cmp %i2, %i3
40011b5c: 18 80 00 25 bgu 40011bf0 <rtems_rfs_group_open+0xbc> <== ALWAYS TAKEN
40011b60: 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))
40011b64: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011b68: 40 00 08 cf call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40011b6c: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40011b70: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011b74: 12 80 00 27 bne 40011c10 <rtems_rfs_group_open+0xdc> <== NOT EXECUTED
40011b78: 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;
40011b7c: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
40011b80: 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;
40011b84: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
40011b88: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
40011b8c: 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,
40011b90: a0 07 20 08 add %i4, 8, %l0
40011b94: b6 07 20 20 add %i4, 0x20, %i3
40011b98: 90 10 00 10 mov %l0, %o0
40011b9c: 92 10 00 1d mov %i5, %o1
40011ba0: 94 10 00 1b mov %i3, %o2
40011ba4: 96 10 00 1a mov %i2, %o3
40011ba8: 40 00 25 8b call 4001b1d4 <rtems_rfs_bitmap_open>
40011bac: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40011bb0: b0 92 20 00 orcc %o0, 0, %i0
40011bb4: 04 80 00 37 ble 40011c90 <rtems_rfs_group_open+0x15c> <== ALWAYS TAKEN
40011bb8: 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);
40011bbc: 40 00 2a 1f call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011bc0: 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))
40011bc4: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011bc8: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
handle->dirty = false;
40011bcc: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40011bd0: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
40011bd4: 40 00 08 b4 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40011bd8: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40011bdc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011be0: 12 80 00 13 bne 40011c2c <rtems_rfs_group_open+0xf8> <== NOT EXECUTED
40011be4: 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;
}
40011be8: 81 c7 e0 08 ret <== NOT EXECUTED
40011bec: 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))
40011bf0: 90 10 20 00 clr %o0
40011bf4: 13 00 00 20 sethi %hi(0x8000), %o1
40011bf8: 40 00 08 ab call 40013ea4 <rtems_rfs_trace>
40011bfc: a2 10 00 1b mov %i3, %l1
40011c00: 80 8a 20 ff btst 0xff, %o0
40011c04: 22 bf ff df be,a 40011b80 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
40011c08: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40011c0c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40011c10: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011c14: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40011c18: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
40011c1c: 40 00 48 d8 call 40023f7c <printf> <== NOT EXECUTED
40011c20: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
base, size, inodes);
group->base = base;
40011c24: 10 bf ff d7 b 40011b80 <rtems_rfs_group_open+0x4c> <== NOT EXECUTED
40011c28: 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",
40011c2c: 40 00 4d 1e call 400250a4 <strerror> <== NOT EXECUTED
40011c30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011c34: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40011c38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011c3c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011c40: 40 00 48 cf call 40023f7c <printf> <== NOT EXECUTED
40011c44: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40035bc8 <_CPU_Trap_slot_template+0x8e0><== NOT EXECUTED
40011c48: 81 c7 e0 08 ret <== NOT EXECUTED
40011c4c: 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))
40011c50: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011c54: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40011c58: 40 00 08 93 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40011c5c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40011c60: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011c64: 02 80 00 3f be 40011d60 <rtems_rfs_group_open+0x22c> <== NOT EXECUTED
40011c68: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
40011c6c: 40 00 4d 0e call 400250a4 <strerror> <== NOT EXECUTED
40011c70: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40011c74: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
40011c78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011c7c: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40011c80: 40 00 48 bf call 40023f7c <printf> <== NOT EXECUTED
40011c84: 90 12 23 50 or %o0, 0x350, %o0 ! 40035b50 <_CPU_Trap_slot_template+0x868><== NOT EXECUTED
40011c88: 81 c7 e0 08 ret <== NOT EXECUTED
40011c8c: 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,
40011c90: 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;
40011c94: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
40011c98: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
40011c9c: c0 27 20 4c clr [ %i4 + 0x4c ]
40011ca0: b4 07 20 44 add %i4, 0x44, %i2
40011ca4: 90 07 20 2c add %i4, 0x2c, %o0
40011ca8: 92 10 00 1d mov %i5, %o1
40011cac: 94 10 00 1a mov %i2, %o2
40011cb0: 96 10 00 11 mov %l1, %o3
40011cb4: 40 00 25 48 call 4001b1d4 <rtems_rfs_bitmap_open>
40011cb8: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40011cbc: b0 92 20 00 orcc %o0, 0, %i0
40011cc0: 04 80 00 1e ble 40011d38 <rtems_rfs_group_open+0x204> <== ALWAYS TAKEN
40011cc4: 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);
40011cc8: 40 00 29 dc call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011ccc: 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);
40011cd0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
handle->dirty = false;
40011cd4: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
40011cd8: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
40011cdc: 40 00 25 4f call 4001b218 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40011ce0: 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);
40011ce4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40011ce8: 40 00 29 d4 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011cec: 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))
40011cf0: 90 10 20 00 clr %o0 <== NOT EXECUTED
40011cf4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
handle->dirty = false;
40011cf8: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40011cfc: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
40011d00: 40 00 08 69 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40011d04: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40011d08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40011d0c: 02 80 00 15 be 40011d60 <rtems_rfs_group_open+0x22c> <== NOT EXECUTED
40011d10: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40011d14: 40 00 4c e4 call 400250a4 <strerror> <== NOT EXECUTED
40011d18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40011d1c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40011d20: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40011d24: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40011d28: 40 00 48 95 call 40023f7c <printf> <== NOT EXECUTED
40011d2c: 90 12 20 08 or %o0, 8, %o0 ! 40035c08 <_CPU_Trap_slot_template+0x920><== NOT EXECUTED
40011d30: 81 c7 e0 08 ret <== NOT EXECUTED
40011d34: 81 e8 00 00 restore <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
40011d38: c2 07 40 00 ld [ %i5 ], %g1
40011d3c: 80 88 60 01 btst 1, %g1
40011d40: 12 bf ff aa bne 40011be8 <rtems_rfs_group_open+0xb4> <== NEVER TAKEN
40011d44: b0 10 20 00 clr %i0
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40011d48: d2 07 20 08 ld [ %i4 + 8 ], %o1
40011d4c: 40 00 29 bb call 4001c438 <rtems_rfs_buffer_handle_release>
40011d50: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40011d54: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40011d58: 40 00 29 b8 call 4001c438 <rtems_rfs_buffer_handle_release>
40011d5c: 90 10 00 1d mov %i5, %o0
}
return 0;
}
40011d60: 81 c7 e0 08 ret
40011d64: 81 e8 00 00 restore
40012280 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
40012280: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
40012284: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40012288: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
4001228c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40012290: 04 80 00 14 ble 400122e0 <rtems_rfs_group_usage+0x60> <== NOT EXECUTED
40012294: 84 10 20 00 clr %g2 <== NOT EXECUTED
40012298: 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) -
4001229c: 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 +=
400122a0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
400122a4: c6 02 40 00 ld [ %o1 ], %g3 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
400122a8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
400122ac: 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 +=
400122b0: 86 20 c0 04 sub %g3, %g4, %g3 <== NOT EXECUTED
400122b4: 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) -
400122b8: 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 +=
400122bc: c8 00 60 3c ld [ %g1 + 0x3c ], %g4 <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
400122c0: c6 02 80 00 ld [ %o2 ], %g3 <== NOT EXECUTED
400122c4: 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 +=
400122c8: 86 20 c0 04 sub %g3, %g4, %g3 <== NOT EXECUTED
400122cc: c6 22 80 00 st %g3, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
400122d0: c6 02 20 24 ld [ %o0 + 0x24 ], %g3 <== NOT EXECUTED
400122d4: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
400122d8: 14 bf ff f1 bg 4001229c <rtems_rfs_group_usage+0x1c> <== NOT EXECUTED
400122dc: 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))
400122e0: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
400122e4: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED
400122e8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400122ec: 38 80 00 02 bgu,a 400122f4 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
400122f0: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
400122f4: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
400122f8: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
400122fc: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
40012300: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40012304: 38 80 00 02 bgu,a 4001230c <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
40012308: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
4001230c: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
40012310: 81 c3 e0 08 retl <== NOT EXECUTED
40012314: 90 10 20 00 clr %o0 <== NOT EXECUTED
400125e8 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400125e8: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
400125ec: 90 10 20 00 clr %o0
400125f0: 40 00 06 2d call 40013ea4 <rtems_rfs_trace>
400125f4: 13 00 02 00 sethi %hi(0x80000), %o1
400125f8: 80 8a 20 ff btst 0xff, %o0
400125fc: 32 80 00 16 bne,a 40012654 <rtems_rfs_inode_close+0x6c> <== NEVER TAKEN
40012600: 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);
40012604: 90 10 00 18 mov %i0, %o0
40012608: 92 10 00 19 mov %i1, %o1
4001260c: 7f ff ff b6 call 400124e4 <rtems_rfs_inode_unload>
40012610: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
40012614: b0 92 20 00 orcc %o0, 0, %i0
40012618: 32 80 00 0d bne,a 4001264c <rtems_rfs_inode_close+0x64> <== NEVER TAKEN
4001261c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
40012620: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40012624: 80 a0 60 00 cmp %g1, 0
40012628: 04 80 00 08 ble 40012648 <rtems_rfs_inode_close+0x60> <== ALWAYS TAKEN
4001262c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40012630: 13 00 02 00 sethi %hi(0x80000), %o1 <== NOT EXECUTED
40012634: 40 00 06 1c call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40012638: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001263c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012640: 32 80 00 0a bne,a 40012668 <rtems_rfs_inode_close+0x80> <== NOT EXECUTED
40012644: 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;
40012648: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
4001264c: 81 c7 e0 08 ret
40012650: 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);
40012654: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40012658: 40 00 46 49 call 40023f7c <printf> <== NOT EXECUTED
4001265c: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 40035df0 <_CPU_Trap_slot_template+0xb08><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40012660: 10 bf ff ea b 40012608 <rtems_rfs_inode_close+0x20> <== NOT EXECUTED
40012664: 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",
40012668: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001266c: 40 00 46 44 call 40023f7c <printf> <== NOT EXECUTED
40012670: 90 12 22 18 or %o0, 0x218, %o0 ! 40035e18 <_CPU_Trap_slot_template+0xb30><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
40012674: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
return rc;
}
40012678: 81 c7 e0 08 ret <== NOT EXECUTED
4001267c: 81 e8 00 00 restore <== NOT EXECUTED
40012950 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40012950: 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))
40012954: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40012958: e4 17 a0 5e lduh [ %fp + 0x5e ], %l2
4001295c: 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))
40012960: 13 00 10 00 sethi %hi(0x400000), %o1
40012964: 40 00 05 50 call 40013ea4 <rtems_rfs_trace>
40012968: a6 0f 30 00 and %i4, -4096, %l3
4001296c: 80 8a 20 ff btst 0xff, %o0
40012970: 22 80 00 28 be,a 40012a10 <rtems_rfs_inode_create+0xc0> <== ALWAYS TAKEN
40012974: a7 2c e0 10 sll %l3, 0x10, %l3
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
40012978: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
4001297c: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40012980: 02 80 00 4f be 40012abc <rtems_rfs_inode_create+0x16c> <== NOT EXECUTED
40012984: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
40012988: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
4001298c: 02 80 00 52 be 40012ad4 <rtems_rfs_inode_create+0x184> <== NOT EXECUTED
40012990: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
40012994: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40012998: 02 80 00 4c be 40012ac8 <rtems_rfs_inode_create+0x178> <== NOT EXECUTED
4001299c: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
400129a0: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
400129a4: 02 80 00 4f be 40012ae0 <rtems_rfs_inode_create+0x190> <== NOT EXECUTED
400129a8: 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";
400129ac: 29 10 00 d7 sethi %hi(0x40035c00), %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))
400129b0: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
400129b4: 02 80 00 4e be 40012aec <rtems_rfs_inode_create+0x19c> <== NOT EXECUTED
400129b8: a8 15 22 90 or %l4, 0x290, %l4 <== NOT EXECUTED
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
400129bc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400129c0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400129c4: 40 00 45 6e call 40023f7c <printf> <== NOT EXECUTED
400129c8: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 40035ea0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
for (c = 0; c < length; c++)
400129cc: a0 10 20 00 clr %l0 <== NOT EXECUTED
400129d0: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
400129d4: 02 80 00 08 be 400129f4 <rtems_rfs_inode_create+0xa4> <== NOT EXECUTED
400129d8: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("%c", name[c]);
400129dc: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 <== NOT EXECUTED
400129e0: 40 00 45 d1 call 40024124 <putchar> <== NOT EXECUTED
400129e4: 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++)
400129e8: 80 a4 00 1b cmp %l0, %i3 <== NOT EXECUTED
400129ec: 12 bf ff fc bne 400129dc <rtems_rfs_inode_create+0x8c> <== NOT EXECUTED
400129f0: 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));
400129f4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400129f8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
400129fc: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
40012a00: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40012a04: 40 00 45 5e call 40023f7c <printf> <== NOT EXECUTED
40012a08: 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)
40012a0c: a7 2c e0 10 sll %l3, 0x10, %l3 <== NOT EXECUTED
40012a10: 05 00 00 18 sethi %hi(0x6000), %g2
40012a14: 83 34 e0 10 srl %l3, 0x10, %g1
40012a18: 80 a0 40 02 cmp %g1, %g2
40012a1c: 02 80 00 15 be 40012a70 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
40012a20: d4 07 a0 64 ld [ %fp + 0x64 ], %o2
40012a24: 08 80 00 0c bleu 40012a54 <rtems_rfs_inode_create+0x104>
40012a28: 05 00 00 08 sethi %hi(0x2000), %g2
40012a2c: 05 00 00 20 sethi %hi(0x8000), %g2
40012a30: 80 a0 40 02 cmp %g1, %g2
40012a34: 02 80 00 0f be 40012a70 <rtems_rfs_inode_create+0x120>
40012a38: 05 00 00 28 sethi %hi(0xa000), %g2
40012a3c: 80 a0 40 02 cmp %g1, %g2
40012a40: 02 80 00 0d be 40012a74 <rtems_rfs_inode_create+0x124> <== ALWAYS TAKEN
40012a44: 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;
40012a48: a0 10 20 16 mov 0x16, %l0 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
}
40012a4c: 81 c7 e0 08 ret
40012a50: 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)
40012a54: 80 a0 40 02 cmp %g1, %g2
40012a58: 02 80 00 05 be 40012a6c <rtems_rfs_inode_create+0x11c> <== NEVER TAKEN
40012a5c: 05 00 00 10 sethi %hi(0x4000), %g2
40012a60: 80 a0 40 02 cmp %g1, %g2
40012a64: 12 bf ff fa bne 40012a4c <rtems_rfs_inode_create+0xfc> <== NEVER TAKEN
40012a68: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
40012a6c: d4 07 a0 64 ld [ %fp + 0x64 ], %o2
40012a70: 90 10 00 18 mov %i0, %o0
40012a74: 7f ff fe 29 call 40012318 <rtems_rfs_inode_alloc>
40012a78: 92 10 00 19 mov %i1, %o1
if (rc > 0)
40012a7c: a0 92 20 00 orcc %o0, 0, %l0
40012a80: 14 bf ff f3 bg 40012a4c <rtems_rfs_inode_create+0xfc>
40012a84: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
40012a88: 90 10 00 18 mov %i0, %o0
40012a8c: d2 00 40 00 ld [ %g1 ], %o1
40012a90: 94 07 bf d8 add %fp, -40, %o2
40012a94: 7f ff fe 5d call 40012408 <rtems_rfs_inode_open>
40012a98: 96 10 20 01 mov 1, %o3
if (rc > 0)
40012a9c: a0 92 20 00 orcc %o0, 0, %l0
40012aa0: 04 80 00 16 ble 40012af8 <rtems_rfs_inode_create+0x1a8> <== ALWAYS TAKEN
40012aa4: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
40012aa8: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
40012aac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012ab0: 7f ff fe 24 call 40012340 <rtems_rfs_inode_free> <== NOT EXECUTED
40012ab4: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
40012ab8: 30 bf ff e5 b,a 40012a4c <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";
40012abc: 29 10 00 d7 sethi %hi(0x40035c00), %l4 <== NOT EXECUTED
40012ac0: 10 bf ff bf b 400129bc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40012ac4: a8 15 22 78 or %l4, 0x278, %l4 ! 40035e78 <_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";
40012ac8: 29 10 00 d7 sethi %hi(0x40035c00), %l4 <== NOT EXECUTED
40012acc: 10 bf ff bc b 400129bc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40012ad0: a8 15 20 78 or %l4, 0x78, %l4 ! 40035c78 <_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";
40012ad4: 29 10 00 d7 sethi %hi(0x40035c00), %l4 <== NOT EXECUTED
40012ad8: 10 bf ff b9 b 400129bc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40012adc: a8 15 22 80 or %l4, 0x280, %l4 ! 40035e80 <_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";
40012ae0: 29 10 00 d7 sethi %hi(0x40035c00), %l4 <== NOT EXECUTED
40012ae4: 10 bf ff b6 b 400129bc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40012ae8: a8 15 22 88 or %l4, 0x288, %l4 ! 40035e88 <_CPU_Trap_slot_template+0xba0><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
40012aec: 29 10 00 d7 sethi %hi(0x40035c00), %l4 <== NOT EXECUTED
40012af0: 10 bf ff b3 b 400129bc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40012af4: a8 15 22 98 or %l4, 0x298, %l4 ! 40035e98 <_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);
40012af8: 92 10 00 1d mov %i5, %o1
40012afc: 94 10 00 1c mov %i4, %o2
40012b00: 96 10 00 12 mov %l2, %o3
40012b04: 7f ff ff 3d call 400127f8 <rtems_rfs_inode_initialise>
40012b08: 98 10 00 11 mov %l1, %o4
if (rc > 0)
40012b0c: a0 92 20 00 orcc %o0, 0, %l0
40012b10: 14 80 00 13 bg 40012b5c <rtems_rfs_inode_create+0x20c> <== NEVER TAKEN
40012b14: 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))
40012b18: 80 a4 c0 01 cmp %l3, %g1
40012b1c: 02 80 00 45 be 40012c30 <rtems_rfs_inode_create+0x2e0>
40012b20: 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);
40012b24: 90 10 00 18 mov %i0, %o0
40012b28: 92 10 00 19 mov %i1, %o1
40012b2c: 94 07 bf b0 add %fp, -80, %o2
40012b30: 7f ff fe 36 call 40012408 <rtems_rfs_inode_open>
40012b34: 96 10 20 01 mov 1, %o3
if (rc > 0)
40012b38: a0 92 20 00 orcc %o0, 0, %l0
40012b3c: 04 80 00 10 ble 40012b7c <rtems_rfs_inode_create+0x22c> <== ALWAYS TAKEN
40012b40: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_delete (fs, &inode);
40012b44: 7f ff fe cf call 40012680 <rtems_rfs_inode_delete> <== NOT EXECUTED
40012b48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012b4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012b50: 7f ff fe a6 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40012b54: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012b58: 30 bf ff bd b,a 40012a4c <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);
40012b5c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012b60: 7f ff fe a2 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40012b64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
40012b68: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
40012b6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012b70: 7f ff fd f4 call 40012340 <rtems_rfs_inode_free> <== NOT EXECUTED
40012b74: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
40012b78: 30 bf ff b5 b,a 40012a4c <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);
40012b7c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
40012b80: 90 10 00 18 mov %i0, %o0
40012b84: d8 00 40 00 ld [ %g1 ], %o4
40012b88: 92 07 bf b0 add %fp, -80, %o1
40012b8c: 94 10 00 1a mov %i2, %o2
40012b90: 40 00 29 e5 call 4001d324 <rtems_rfs_dir_add_entry>
40012b94: 96 10 00 1b mov %i3, %o3
if (rc > 0)
40012b98: a0 92 20 00 orcc %o0, 0, %l0
40012b9c: 14 80 00 3c bg 40012c8c <rtems_rfs_inode_create+0x33c> <== NEVER TAKEN
40012ba0: 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))
40012ba4: 80 a4 c0 01 cmp %l3, %g1
40012ba8: 12 80 00 15 bne 40012bfc <rtems_rfs_inode_create+0x2ac>
40012bac: 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);
40012bb0: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
links = 0;
40012bb4: 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);
40012bb8: c6 08 40 00 ldub [ %g1 ], %g3
40012bbc: c4 08 60 01 ldub [ %g1 + 1 ], %g2
40012bc0: 87 28 e0 08 sll %g3, 8, %g3
40012bc4: 84 10 c0 02 or %g3, %g2, %g2
if (links == 0xffff)
40012bc8: 87 28 a0 10 sll %g2, 0x10, %g3
40012bcc: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
40012bd0: 86 39 00 03 xnor %g4, %g3, %g3
40012bd4: 80 a0 00 03 cmp %g0, %g3
40012bd8: 86 60 20 00 subx %g0, 0, %g3
40012bdc: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
40012be0: 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);
40012be4: 87 30 a0 08 srl %g2, 8, %g3
40012be8: c6 28 40 00 stb %g3, [ %g1 ]
40012bec: c2 07 bf bc ld [ %fp + -68 ], %g1
40012bf0: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012bf4: 82 10 20 01 mov 1, %g1
40012bf8: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
40012bfc: 7f ff fe 7b call 400125e8 <rtems_rfs_inode_close>
40012c00: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
40012c04: 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);
40012c08: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40012c0c: 80 a4 20 00 cmp %l0, 0
40012c10: 04 80 00 29 ble 40012cb4 <rtems_rfs_inode_create+0x364> <== ALWAYS TAKEN
40012c14: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
40012c18: 7f ff fe 9a call 40012680 <rtems_rfs_inode_delete> <== NOT EXECUTED
40012c1c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012c20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012c24: 7f ff fe 71 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40012c28: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012c2c: 30 bf ff 88 b,a 40012a4c <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);
40012c30: 90 10 00 18 mov %i0, %o0
40012c34: d8 00 40 00 ld [ %g1 ], %o4
40012c38: 92 07 bf d8 add %fp, -40, %o1
40012c3c: 96 10 20 01 mov 1, %o3
40012c40: 15 10 00 cf sethi %hi(0x40033c00), %o2
40012c44: 40 00 29 b8 call 4001d324 <rtems_rfs_dir_add_entry>
40012c48: 94 12 a0 10 or %o2, 0x10, %o2 ! 40033c10 <flashdisk_ops+0x1c>
if (rc == 0)
40012c4c: a0 92 20 00 orcc %o0, 0, %l0
40012c50: 12 80 00 0b bne 40012c7c <rtems_rfs_inode_create+0x32c> <== NEVER TAKEN
40012c54: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
40012c58: 90 10 00 18 mov %i0, %o0
40012c5c: 92 07 bf d8 add %fp, -40, %o1
40012c60: 96 10 20 02 mov 2, %o3
40012c64: 15 10 00 cf sethi %hi(0x40033c00), %o2
40012c68: 98 10 00 19 mov %i1, %o4
40012c6c: 40 00 29 ae call 4001d324 <rtems_rfs_dir_add_entry>
40012c70: 94 12 a0 18 or %o2, 0x18, %o2
40012c74: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40012c78: 80 a4 20 00 cmp %l0, 0
40012c7c: 04 bf ff ab ble 40012b28 <rtems_rfs_inode_create+0x1d8> <== ALWAYS TAKEN
40012c80: 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);
40012c84: 10 bf ff b0 b 40012b44 <rtems_rfs_inode_create+0x1f4> <== NOT EXECUTED
40012c88: 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);
40012c8c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012c90: 7f ff fe 7c call 40012680 <rtems_rfs_inode_delete> <== NOT EXECUTED
40012c94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40012c98: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40012c9c: 7f ff fe 53 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40012ca0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40012ca4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012ca8: 7f ff fe 50 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40012cac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40012cb0: 30 bf ff 67 b,a 40012a4c <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);
40012cb4: 7f ff fe 4d call 400125e8 <rtems_rfs_inode_close>
40012cb8: 01 00 00 00 nop
if (rc > 0)
40012cbc: a0 92 20 00 orcc %o0, 0, %l0
40012cc0: 14 bf ff 7b bg 40012aac <rtems_rfs_inode_create+0x15c> <== NEVER TAKEN
40012cc4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
40012cc8: 10 bf ff 61 b 40012a4c <rtems_rfs_inode_create+0xfc>
40012ccc: a0 10 20 00 clr %l0
40012680 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40012680: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
40012684: 90 10 20 00 clr %o0
40012688: 40 00 06 07 call 40013ea4 <rtems_rfs_trace>
4001268c: 13 00 20 00 sethi %hi(0x800000), %o1
40012690: 80 8a 20 ff btst 0xff, %o0
40012694: 02 80 00 0b be 400126c0 <rtems_rfs_inode_delete+0x40> <== ALWAYS TAKEN
40012698: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
4001269c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400126a0: 02 80 00 13 be 400126ec <rtems_rfs_inode_delete+0x6c> <== NOT EXECUTED
400126a4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400126a8: 15 10 00 d7 sethi %hi(0x40035c00), %o2 <== NOT EXECUTED
400126ac: 94 12 a1 50 or %o2, 0x150, %o2 ! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
400126b0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400126b4: 40 00 46 32 call 40023f7c <printf> <== NOT EXECUTED
400126b8: 90 12 22 48 or %o0, 0x248, %o0 ! 40035e48 <_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))
400126bc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
400126c0: 80 a0 60 00 cmp %g1, 0
400126c4: 02 80 00 08 be 400126e4 <rtems_rfs_inode_delete+0x64> <== NEVER TAKEN
400126c8: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
400126cc: d2 06 60 08 ld [ %i1 + 8 ], %o1
400126d0: 7f ff ff 1c call 40012340 <rtems_rfs_inode_free>
400126d4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400126d8: 80 a2 20 00 cmp %o0, 0
400126dc: 24 80 00 07 ble,a 400126f8 <rtems_rfs_inode_delete+0x78> <== ALWAYS TAKEN
400126e0: 90 10 00 18 mov %i0, %o0
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
400126e4: 81 c7 e0 08 ret
400126e8: 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",
400126ec: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED
400126f0: 10 bf ff f0 b 400126b0 <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
400126f4: 94 12 a0 00 mov %o2, %o2 ! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
400126f8: 92 10 00 19 mov %i1, %o1
400126fc: 40 00 23 c5 call 4001b610 <rtems_rfs_block_map_open>
40012700: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
40012704: 80 a2 20 00 cmp %o0, 0
40012708: 12 bf ff f7 bne 400126e4 <rtems_rfs_inode_delete+0x64> <== NEVER TAKEN
4001270c: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
40012710: 40 00 26 d7 call 4001c26c <rtems_rfs_block_map_free_all>
40012714: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
40012718: 92 07 bf b0 add %fp, -80, %o1
4001271c: 40 00 24 1e call 4001b794 <rtems_rfs_block_map_close>
40012720: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40012724: d0 06 60 0c ld [ %i1 + 0xc ], %o0
40012728: 92 10 20 ff mov 0xff, %o1
4001272c: 40 00 45 96 call 40023d84 <memset>
40012730: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40012734: 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);
40012738: 90 10 00 18 mov %i0, %o0
4001273c: 92 06 60 10 add %i1, 0x10, %o1
40012740: 40 00 27 3e call 4001c438 <rtems_rfs_buffer_handle_release>
40012744: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
handle->loads = 0;
40012748: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
4001274c: 10 bf ff e6 b 400126e4 <rtems_rfs_inode_delete+0x64>
40012750: c0 26 60 0c clr [ %i1 + 0xc ]
40012354 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40012354: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
40012358: 90 10 20 00 clr %o0
4001235c: 40 00 06 d2 call 40013ea4 <rtems_rfs_trace>
40012360: 13 00 04 00 sethi %hi(0x100000), %o1
40012364: 80 8a 20 ff btst 0xff, %o0
40012368: 02 80 00 0c be 40012398 <rtems_rfs_inode_load+0x44> <== ALWAYS TAKEN
4001236c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40012370: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40012374: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40012378: 02 80 00 11 be 400123bc <rtems_rfs_inode_load+0x68> <== NOT EXECUTED
4001237c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40012380: 17 10 00 d7 sethi %hi(0x40035c00), %o3 <== NOT EXECUTED
40012384: 96 12 e1 50 or %o3, 0x150, %o3 ! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40012388: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001238c: 40 00 46 fc call 40023f7c <printf> <== NOT EXECUTED
40012390: 90 12 21 58 or %o0, 0x158, %o0 ! 40035d58 <_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))
40012394: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40012398: 80 a0 60 00 cmp %g1, 0
4001239c: 22 80 00 0b be,a 400123c8 <rtems_rfs_inode_load+0x74>
400123a0: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400123a4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
400123a8: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400123ac: 82 00 60 01 inc %g1
400123b0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
400123b4: 81 c7 e0 08 ret
400123b8: 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",
400123bc: 17 10 00 d1 sethi %hi(0x40034400), %o3 <== NOT EXECUTED
400123c0: 10 bf ff f2 b 40012388 <rtems_rfs_inode_load+0x34> <== NOT EXECUTED
400123c4: 96 12 e0 00 mov %o3, %o3 ! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
if (!rtems_rfs_inode_is_loaded (handle))
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
400123c8: 90 10 00 18 mov %i0, %o0
400123cc: 92 06 60 10 add %i1, 0x10, %o1
400123d0: 40 00 28 94 call 4001c620 <rtems_rfs_buffer_handle_request>
400123d4: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
400123d8: b0 92 20 00 orcc %o0, 0, %i0
400123dc: 14 bf ff f6 bg 400123b4 <rtems_rfs_inode_load+0x60> <== NEVER TAKEN
400123e0: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
400123e4: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
400123e8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400123ec: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400123f0: 87 28 60 03 sll %g1, 3, %g3
400123f4: 83 28 60 06 sll %g1, 6, %g1
400123f8: 82 20 40 03 sub %g1, %g3, %g1
400123fc: 82 00 80 01 add %g2, %g1, %g1
40012400: 10 bf ff e9 b 400123a4 <rtems_rfs_inode_load+0x50>
40012404: c2 26 60 0c st %g1, [ %i1 + 0xc ]
40012408 <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)
{
40012408: 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))
4001240c: 90 10 20 00 clr %o0
40012410: 40 00 06 a5 call 40013ea4 <rtems_rfs_trace>
40012414: 13 00 01 00 sethi %hi(0x40000), %o1
40012418: 80 8a 20 ff btst 0xff, %o0
4001241c: 32 80 00 2d bne,a 400124d0 <rtems_rfs_inode_open+0xc8> <== NEVER TAKEN
40012420: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
40012424: 80 a6 60 00 cmp %i1, 0
40012428: 12 80 00 04 bne 40012438 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
4001242c: 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;
}
40012430: 81 c7 e0 08 ret <== NOT EXECUTED
40012434: 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))
40012438: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4001243c: ba 06 7f ff add %i1, -1, %i5
40012440: 80 a7 40 02 cmp %i5, %g2
40012444: 18 bf ff fb bgu 40012430 <rtems_rfs_inode_open+0x28> <== NEVER TAKEN
40012448: 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;
4001244c: 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;
40012450: 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;
40012454: 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;
40012458: 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;
4001245c: 40 00 78 5e call 400305d4 <.urem>
40012460: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40012464: 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;
40012468: 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;
4001246c: 40 00 78 5a call 400305d4 <.urem>
40012470: 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;
40012474: 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;
40012478: 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;
4001247c: 7f ff c0 89 call 400026a0 <.udiv>
40012480: 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);
40012484: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
40012488: 87 2a 20 04 sll %o0, 4, %g3
4001248c: 83 2a 20 06 sll %o0, 6, %g1
40012490: 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;
40012494: fa 00 80 01 ld [ %g2 + %g1 ], %i5
40012498: 90 10 00 19 mov %i1, %o0
4001249c: ba 07 60 02 add %i5, 2, %i5
400124a0: 7f ff c0 80 call 400026a0 <.udiv>
400124a4: 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;
400124a8: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400124ac: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
400124b0: c0 26 a0 14 clr [ %i2 + 0x14 ]
400124b4: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
400124b8: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
400124bc: 80 a6 e0 00 cmp %i3, 0
400124c0: 02 bf ff dc be 40012430 <rtems_rfs_inode_open+0x28> <== NEVER TAKEN
400124c4: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
400124c8: 7f ff ff a3 call 40012354 <rtems_rfs_inode_load>
400124cc: 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);
400124d0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400124d4: 40 00 46 aa call 40023f7c <printf> <== NOT EXECUTED
400124d8: 90 12 21 90 or %o0, 0x190, %o0 ! 40035d90 <_CPU_Trap_slot_template+0xaa8><== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
400124dc: 10 bf ff d3 b 40012428 <rtems_rfs_inode_open+0x20> <== NOT EXECUTED
400124e0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40012754 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40012754: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40012758: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
4001275c: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40012760: 80 a0 60 00 cmp %g1, 0
40012764: 02 80 00 23 be 400127f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
40012768: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
4001276c: 40 00 56 48 call 4002808c <time>
40012770: 90 10 20 00 clr %o0
if (atime)
40012774: 80 a6 60 00 cmp %i1, 0
40012778: 02 80 00 0f be 400127b4 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
4001277c: 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);
40012780: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012784: 85 32 20 18 srl %o0, 0x18, %g2
40012788: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
4001278c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40012790: 85 32 20 10 srl %o0, 0x10, %g2
40012794: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
40012798: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001279c: 85 32 20 08 srl %o0, 8, %g2
400127a0: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
400127a4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400127a8: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400127ac: 82 10 20 01 mov 1, %g1
400127b0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
400127b4: 02 80 00 0f be 400127f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
400127b8: 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);
400127bc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400127c0: 85 32 20 18 srl %o0, 0x18, %g2
400127c4: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
400127c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400127cc: 85 32 20 10 srl %o0, 0x10, %g2
400127d0: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
400127d4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400127d8: 85 32 20 08 srl %o0, 8, %g2
400127dc: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
400127e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400127e4: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400127e8: 82 10 20 01 mov 1, %g1
400127ec: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
400127f0: 81 c7 e0 08 ret
400127f4: 81 e8 00 00 restore
400124e4 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
400124e4: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
400124e8: 90 10 20 00 clr %o0
400124ec: 40 00 06 6e call 40013ea4 <rtems_rfs_trace>
400124f0: 13 00 08 00 sethi %hi(0x200000), %o1
400124f4: 80 8a 20 ff btst 0xff, %o0
400124f8: 02 80 00 0c be 40012528 <rtems_rfs_inode_unload+0x44> <== ALWAYS TAKEN
400124fc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40012500: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40012504: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40012508: 02 80 00 25 be 4001259c <rtems_rfs_inode_unload+0xb8> <== NOT EXECUTED
4001250c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40012510: 17 10 00 d7 sethi %hi(0x40035c00), %o3 <== NOT EXECUTED
40012514: 96 12 e1 50 or %o3, 0x150, %o3 ! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40012518: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4001251c: 40 00 46 98 call 40023f7c <printf> <== NOT EXECUTED
40012520: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 40035db8 <_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))
40012524: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40012528: 80 a0 60 00 cmp %g1, 0
4001252c: 22 80 00 0d be,a 40012560 <rtems_rfs_inode_unload+0x7c>
40012530: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
40012534: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40012538: 80 a0 a0 00 cmp %g2, 0
4001253c: 12 80 00 04 bne 4001254c <rtems_rfs_inode_unload+0x68> <== ALWAYS TAKEN
40012540: 90 10 20 05 mov 5, %o0
handle->node = NULL;
}
}
return rc;
}
40012544: 81 c7 e0 08 ret <== NOT EXECUTED
40012548: 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--;
4001254c: 84 00 bf ff add %g2, -1, %g2
if (handle->loads == 0)
40012550: 80 a0 a0 00 cmp %g2, 0
40012554: 02 80 00 05 be 40012568 <rtems_rfs_inode_unload+0x84>
40012558: 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;
4001255c: 90 10 20 00 clr %o0
handle->node = NULL;
}
}
return rc;
}
40012560: 81 c7 e0 08 ret
40012564: 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)
40012568: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
4001256c: 80 a0 60 00 cmp %g1, 0
40012570: 02 80 00 06 be 40012588 <rtems_rfs_inode_unload+0xa4>
40012574: 90 10 00 18 mov %i0, %o0
40012578: 80 a6 a0 00 cmp %i2, 0
4001257c: 12 80 00 0b bne 400125a8 <rtems_rfs_inode_unload+0xc4> <== ALWAYS TAKEN
40012580: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40012584: 90 10 00 18 mov %i0, %o0
40012588: 40 00 27 ac call 4001c438 <rtems_rfs_buffer_handle_release>
4001258c: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
40012590: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
40012594: 81 c7 e0 08 ret
40012598: 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",
4001259c: 17 10 00 d1 sethi %hi(0x40034400), %o3 <== NOT EXECUTED
400125a0: 10 bf ff de b 40012518 <rtems_rfs_inode_unload+0x34> <== NOT EXECUTED
400125a4: 96 12 e0 00 mov %o3, %o3 ! 40034400 <__FUNCTION__.6193+0x338><== 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));
400125a8: 40 00 56 b9 call 4002808c <time>
400125ac: 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);
400125b0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400125b4: 85 32 20 18 srl %o0, 0x18, %g2
400125b8: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
400125bc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400125c0: 85 32 20 10 srl %o0, 0x10, %g2
400125c4: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
400125c8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400125cc: 85 32 20 08 srl %o0, 8, %g2
400125d0: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
400125d4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400125d8: d0 28 60 1b stb %o0, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400125dc: 82 10 20 01 mov 1, %g1
400125e0: 10 bf ff e9 b 40012584 <rtems_rfs_inode_unload+0xa0>
400125e4: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
4001fb98 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
4001fb98: 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))
4001fb9c: 90 10 20 00 clr %o0
4001fba0: 13 00 40 00 sethi %hi(0x1000000), %o1
4001fba4: 7f ff d0 c0 call 40013ea4 <rtems_rfs_trace>
4001fba8: a2 10 00 18 mov %i0, %l1
4001fbac: 80 8a 20 ff btst 0xff, %o0
4001fbb0: 12 80 00 52 bne 4001fcf8 <rtems_rfs_link+0x160> <== NEVER TAKEN
4001fbb4: 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);
4001fbb8: 90 10 00 11 mov %l1, %o0
4001fbbc: 92 10 00 1c mov %i4, %o1
4001fbc0: 94 07 bf d8 add %fp, -40, %o2
4001fbc4: 7f ff ca 11 call 40012408 <rtems_rfs_inode_open>
4001fbc8: 96 10 20 01 mov 1, %o3
if (rc)
4001fbcc: b0 92 20 00 orcc %o0, 0, %i0
4001fbd0: 12 80 00 3d bne 4001fcc4 <rtems_rfs_link+0x12c> <== NEVER TAKEN
4001fbd4: 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)))
4001fbd8: 12 80 00 0b bne 4001fc04 <rtems_rfs_link+0x6c> <== NEVER TAKEN
4001fbdc: 90 10 00 11 mov %l1, %o0
4001fbe0: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001fbe4: c4 08 60 02 ldub [ %g1 + 2 ], %g2
4001fbe8: 03 00 00 3c sethi %hi(0xf000), %g1
4001fbec: 85 28 a0 08 sll %g2, 8, %g2
4001fbf0: 84 08 80 01 and %g2, %g1, %g2
4001fbf4: 03 00 00 10 sethi %hi(0x4000), %g1
4001fbf8: 80 a0 80 01 cmp %g2, %g1
4001fbfc: 02 80 00 55 be 4001fd50 <rtems_rfs_link+0x1b8> <== NEVER TAKEN
4001fc00: 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);
4001fc04: 92 10 00 1b mov %i3, %o1
4001fc08: 94 07 bf b0 add %fp, -80, %o2
4001fc0c: 7f ff c9 ff call 40012408 <rtems_rfs_inode_open>
4001fc10: 96 10 20 01 mov 1, %o3
4001fc14: b0 10 00 08 mov %o0, %i0
if (rc)
4001fc18: 80 a6 20 00 cmp %i0, 0
4001fc1c: 12 80 00 27 bne 4001fcb8 <rtems_rfs_link+0x120> <== NEVER TAKEN
4001fc20: 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);
4001fc24: 92 07 bf b0 add %fp, -80, %o1
4001fc28: 94 10 00 19 mov %i1, %o2
4001fc2c: 96 10 00 1a mov %i2, %o3
4001fc30: 7f ff f5 bd call 4001d324 <rtems_rfs_dir_add_entry>
4001fc34: 98 10 00 1c mov %i4, %o4
if (rc > 0)
4001fc38: b0 92 20 00 orcc %o0, 0, %i0
4001fc3c: 14 80 00 42 bg 4001fd44 <rtems_rfs_link+0x1ac> <== NEVER TAKEN
4001fc40: 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);
4001fc44: c6 08 60 01 ldub [ %g1 + 1 ], %g3
4001fc48: c4 08 40 00 ldub [ %g1 ], %g2
4001fc4c: 85 28 a0 08 sll %g2, 8, %g2
4001fc50: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
4001fc54: 07 3f ff c0 sethi %hi(0xffff0000), %g3
4001fc58: 89 28 a0 10 sll %g2, 0x10, %g4
4001fc5c: 80 a1 00 03 cmp %g4, %g3
4001fc60: 22 80 00 40 be,a 4001fd60 <rtems_rfs_link+0x1c8> <== NEVER TAKEN
4001fc64: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4001fc68: 84 00 a0 01 inc %g2
4001fc6c: 87 28 a0 10 sll %g2, 0x10, %g3
4001fc70: 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);
4001fc74: c6 28 40 00 stb %g3, [ %g1 ]
4001fc78: 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);
4001fc7c: 92 10 20 01 mov 1, %o1
4001fc80: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001fc84: 82 10 20 01 mov 1, %g1
4001fc88: 90 07 bf b0 add %fp, -80, %o0
4001fc8c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4001fc90: 7f ff ca b1 call 40012754 <rtems_rfs_inode_time_stamp_now>
4001fc94: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
4001fc98: 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);
4001fc9c: b0 10 00 08 mov %o0, %i0
if (rc > 0)
4001fca0: 80 a6 20 00 cmp %i0, 0
4001fca4: 04 80 00 0a ble 4001fccc <rtems_rfs_link+0x134> <== ALWAYS TAKEN
4001fca8: 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);
4001fcac: 7f ff ca 4f call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fcb0: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001fcb4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001fcb8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001fcbc: 7f ff ca 4b call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fcc0: 01 00 00 00 nop <== NOT EXECUTED
4001fcc4: 81 c7 e0 08 ret <== NOT EXECUTED
4001fcc8: 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);
4001fccc: 7f ff ca 47 call 400125e8 <rtems_rfs_inode_close>
4001fcd0: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
4001fcd4: 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);
4001fcd8: b0 10 00 08 mov %o0, %i0
if (rc > 0)
4001fcdc: 80 a6 20 00 cmp %i0, 0
4001fce0: 14 bf ff f7 bg 4001fcbc <rtems_rfs_link+0x124> <== NEVER TAKEN
4001fce4: 90 10 00 11 mov %l1, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
4001fce8: 7f ff ca 40 call 400125e8 <rtems_rfs_inode_close>
4001fcec: 01 00 00 00 nop
return rc;
}
4001fcf0: 81 c7 e0 08 ret
4001fcf4: 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);
4001fcf8: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001fcfc: 40 00 10 a0 call 40023f7c <printf> <== NOT EXECUTED
4001fd00: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 40037ff8 <CSWTCH.2+0x1408><== NOT EXECUTED
4001fd04: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
4001fd08: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001fd0c: 04 80 00 08 ble 4001fd2c <rtems_rfs_link+0x194> <== NOT EXECUTED
4001fd10: b0 06 40 1a add %i1, %i2, %i0 <== NOT EXECUTED
printf ("%c", name[c]);
4001fd14: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
4001fd18: 40 00 11 03 call 40024124 <putchar> <== NOT EXECUTED
4001fd1c: 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++)
4001fd20: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED
4001fd24: 32 bf ff fd bne,a 4001fd18 <rtems_rfs_link+0x180> <== NOT EXECUTED
4001fd28: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
4001fd2c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001fd30: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001fd34: 40 00 10 92 call 40023f7c <printf> <== NOT EXECUTED
4001fd38: 90 12 20 20 or %o0, 0x20, %o0 ! 40038020 <CSWTCH.2+0x1430><== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001fd3c: 10 bf ff a0 b 4001fbbc <rtems_rfs_link+0x24> <== NOT EXECUTED
4001fd40: 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);
4001fd44: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001fd48: 10 bf ff d9 b 4001fcac <rtems_rfs_link+0x114> <== NOT EXECUTED
4001fd4c: 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);
4001fd50: 7f ff ca 26 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fd54: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001fd58: 81 c7 e0 08 ret <== NOT EXECUTED
4001fd5c: 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)
4001fd60: 10 bf ff c5 b 4001fc74 <rtems_rfs_link+0xdc> <== NOT EXECUTED
4001fd64: 86 10 20 00 clr %g3 <== NOT EXECUTED
400205cc <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
400205cc: 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'),
400205d0: 92 10 20 01 mov 1, %o1
400205d4: 98 10 00 18 mov %i0, %o4
400205d8: 11 14 91 94 sethi %hi(0x52465000), %o0
400205dc: 94 10 20 54 mov 0x54, %o2
400205e0: 90 12 23 6d or %o0, 0x36d, %o0
400205e4: 96 10 20 00 clr %o3
400205e8: 7f ff b1 18 call 4000ca48 <rtems_semaphore_create>
400205ec: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
400205f0: 80 a2 20 00 cmp %o0, 0
400205f4: 02 80 00 0f be 40020630 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
400205f8: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400205fc: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020600: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020604: 7f ff ce 28 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020608: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4002060c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020610: 02 80 00 08 be 40020630 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
40020614: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
40020618: 7f ff dc 7e call 40017810 <rtems_status_text> <== NOT EXECUTED
4002061c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020620: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020624: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
40020628: 40 00 0e 55 call 40023f7c <printf> <== NOT EXECUTED
4002062c: 90 12 22 50 or %o0, 0x250, %o0 ! 40038250 <CSWTCH.2+0x1660><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
40020630: 81 c7 e0 08 ret
40020634: 81 e8 00 00 restore
40020638 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
40020638: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
4002063c: d0 06 00 00 ld [ %i0 ], %o0
40020640: 7f ff b1 73 call 4000cc0c <rtems_semaphore_delete>
40020644: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
40020648: ba 92 20 00 orcc %o0, 0, %i5
4002064c: 02 80 00 0e be 40020684 <rtems_rfs_mutex_destroy+0x4c> <== ALWAYS TAKEN
40020650: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020654: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020658: 7f ff ce 13 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4002065c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40020660: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020664: 02 80 00 08 be 40020684 <rtems_rfs_mutex_destroy+0x4c> <== NOT EXECUTED
40020668: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
4002066c: 7f ff dc 69 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020670: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020674: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020678: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4002067c: 40 00 0e 40 call 40023f7c <printf> <== NOT EXECUTED
40020680: 90 12 22 78 or %o0, 0x278, %o0 ! 40038278 <CSWTCH.2+0x1688><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
40020684: 81 c7 e0 08 ret
40020688: 81 e8 00 00 restore
4001c27c <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
4001c27c: 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))
4001c280: 90 10 20 00 clr %o0
4001c284: 92 10 20 80 mov 0x80, %o1
4001c288: 7f ff df 07 call 40013ea4 <rtems_rfs_trace>
4001c28c: ba 10 00 18 mov %i0, %i5
4001c290: 80 8a 20 ff btst 0xff, %o0
4001c294: 32 80 00 1c bne,a 4001c304 <rtems_rfs_release_chain+0x88><== NEVER TAKEN
4001c298: 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))
4001c29c: b0 10 20 00 clr %i0
4001c2a0: 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))
4001c2a4: c2 07 40 00 ld [ %i5 ], %g1
4001c2a8: 80 a0 40 1c cmp %g1, %i4
4001c2ac: 02 80 00 14 be 4001c2fc <rtems_rfs_release_chain+0x80>
4001c2b0: 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 );
4001c2b4: 7f ff c5 69 call 4000d858 <_Chain_Get>
4001c2b8: 01 00 00 00 nop
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
4001c2bc: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001c2c0: 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)--;
4001c2c4: 82 00 7f ff add %g1, -1, %g1
4001c2c8: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001c2cc: 40 00 18 7b call 400224b8 <rtems_rfs_buffer_bdbuf_release>
4001c2d0: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
4001c2d4: 80 a2 20 00 cmp %o0, 0
4001c2d8: 04 bf ff f4 ble 4001c2a8 <rtems_rfs_release_chain+0x2c> <== ALWAYS TAKEN
4001c2dc: c2 07 40 00 ld [ %i5 ], %g1
4001c2e0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001c2e4: 12 bf ff f1 bne 4001c2a8 <rtems_rfs_release_chain+0x2c> <== NOT EXECUTED
4001c2e8: 01 00 00 00 nop <== NOT EXECUTED
4001c2ec: 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))
4001c2f0: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
4001c2f4: 12 bf ff f0 bne 4001c2b4 <rtems_rfs_release_chain+0x38> <== NOT EXECUTED
4001c2f8: 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;
}
4001c2fc: 81 c7 e0 08 ret
4001c300: 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);
4001c304: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c308: 40 00 1f 1d call 40023f7c <printf> <== NOT EXECUTED
4001c30c: 90 12 21 00 or %o0, 0x100, %o0 ! 40036d00 <CSWTCH.2+0x110><== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
4001c310: 10 bf ff e4 b 4001c2a0 <rtems_rfs_release_chain+0x24> <== NOT EXECUTED
4001c314: b0 10 20 00 clr %i0 <== NOT EXECUTED
400130d0 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
400130d0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400130d4: 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);
400130d8: 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);
400130dc: 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);
400130e0: 94 07 bf d8 add %fp, -40, %o2
400130e4: 90 10 00 1c mov %i4, %o0
400130e8: 7f ff fc c8 call 40012408 <rtems_rfs_inode_open>
400130ec: 96 10 20 01 mov 1, %o3
if (rc > 0)
400130f0: ba 92 20 00 orcc %o0, 0, %i5
400130f4: 04 80 00 07 ble 40013110 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
400130f8: 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);
400130fc: 40 00 3e 0f call 40022938 <__errno> <== NOT EXECUTED
40013100: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40013104: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40013108: 81 c7 e0 08 ret <== NOT EXECUTED
4001310c: 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();
40013110: 40 00 12 95 call 40017b64 <geteuid>
40013114: 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;
40013118: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4001311c: 91 2a 20 10 sll %o0, 0x10, %o0
40013120: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40013124: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40013128: 85 28 a0 08 sll %g2, 8, %g2
4001312c: 84 10 80 03 or %g2, %g3, %g2
40013130: 85 28 a0 10 sll %g2, 0x10, %g2
40013134: 80 a0 80 08 cmp %g2, %o0
40013138: 02 80 00 05 be 4001314c <rtems_rfs_rtems_chown+0x7c> <== ALWAYS TAKEN
4001313c: 89 32 20 10 srl %o0, 0x10, %g4
40013140: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40013144: 12 80 00 19 bne 400131a8 <rtems_rfs_rtems_chown+0xd8> <== NOT EXECUTED
40013148: 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);
4001314c: b5 2e a0 10 sll %i2, 0x10, %i2
40013150: b4 16 80 19 or %i2, %i1, %i2
40013154: 85 36 a0 18 srl %i2, 0x18, %g2
40013158: c4 28 60 04 stb %g2, [ %g1 + 4 ]
4001315c: c2 07 bf e4 ld [ %fp + -28 ], %g1
40013160: 85 36 a0 10 srl %i2, 0x10, %g2
40013164: c4 28 60 05 stb %g2, [ %g1 + 5 ]
40013168: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001316c: b5 36 a0 08 srl %i2, 8, %i2
40013170: f4 28 60 06 stb %i2, [ %g1 + 6 ]
40013174: 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);
40013178: 90 10 00 1c mov %i4, %o0
4001317c: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013180: 82 10 20 01 mov 1, %g1
40013184: 92 07 bf d8 add %fp, -40, %o1
40013188: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4001318c: 7f ff fd 17 call 400125e8 <rtems_rfs_inode_close>
40013190: b0 10 20 00 clr %i0
if (rc)
40013194: 80 a2 20 00 cmp %o0, 0
40013198: 12 bf ff d9 bne 400130fc <rtems_rfs_rtems_chown+0x2c> <== NEVER TAKEN
4001319c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
return 0;
}
400131a0: 81 c7 e0 08 ret
400131a4: 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);
400131a8: 7f ff fd 10 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
400131ac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
400131b0: 40 00 3d e2 call 40022938 <__errno> <== NOT EXECUTED
400131b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400131b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400131bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400131c0: 81 c7 e0 08 ret <== NOT EXECUTED
400131c4: 81 e8 00 00 restore <== NOT EXECUTED
400206d0 <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);
400206d0: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
400206d4: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
400206d8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400206dc: 40 00 05 24 call 40021b6c <rtems_deviceio_close> <== NOT EXECUTED
400206e0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4002068c <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
4002068c: 81 c3 e0 08 retl <== NOT EXECUTED
40020690: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020694 <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);
40020694: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
40020698: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4002069c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400206a0: 40 00 05 75 call 40021c74 <rtems_deviceio_control> <== NOT EXECUTED
400206a4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400206e4 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
400206e4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400206e8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
400206ec: 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);
400206f0: 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);
400206f4: 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
};
400206f8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
400206fc: 94 10 20 00 clr %o2 <== NOT EXECUTED
40020700: 7f ff b1 7a call 4000cce8 <rtems_semaphore_obtain> <== NOT EXECUTED
40020704: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020708: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4002070c: 12 80 00 17 bne 40020768 <rtems_rfs_rtems_device_open+0x84><== NOT EXECUTED
40020710: 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);
40020714: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020718: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4002071c: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40020720: 7f ff c7 3a call 40012408 <rtems_rfs_inode_open> <== NOT EXECUTED
40020724: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
40020728: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4002072c: 04 80 00 23 ble 400207b8 <rtems_rfs_rtems_device_open+0xd4><== NOT EXECUTED
40020730: 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);
40020734: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40020738: 7f ff f1 04 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
4002073c: 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);
40020740: 7f ff b1 b9 call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40020744: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020748: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4002074c: 12 80 00 4c bne 4002087c <rtems_rfs_rtems_device_open+0x198><== NOT EXECUTED
40020750: 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);
40020754: 40 00 08 79 call 40022938 <__errno> <== NOT EXECUTED
40020758: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4002075c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40020760: 81 c7 e0 08 ret <== NOT EXECUTED
40020764: 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))
40020768: 7f ff cd cf call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4002076c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020770: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020774: 22 bf ff e9 be,a 40020718 <rtems_rfs_rtems_device_open+0x34><== NOT EXECUTED
40020778: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4002077c: 7f ff dc 25 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020780: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40020784: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020788: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
4002078c: 40 00 0d fc call 40023f7c <printf> <== NOT EXECUTED
40020790: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
40020794: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020798: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4002079c: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
400207a0: 7f ff c7 1a call 40012408 <rtems_rfs_inode_open> <== NOT EXECUTED
400207a4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
400207a8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400207ac: 34 bf ff e3 bg,a 40020738 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400207b0: 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]);
400207b4: 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);
400207b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400207bc: ec 08 60 1c ldub [ %g1 + 0x1c ], %l6 <== NOT EXECUTED
400207c0: ea 08 60 1d ldub [ %g1 + 0x1d ], %l5 <== NOT EXECUTED
400207c4: e6 08 60 1e ldub [ %g1 + 0x1e ], %l3 <== NOT EXECUTED
400207c8: e8 08 60 1f ldub [ %g1 + 0x1f ], %l4 <== NOT EXECUTED
400207cc: e4 08 60 20 ldub [ %g1 + 0x20 ], %l2 <== NOT EXECUTED
400207d0: e2 08 60 21 ldub [ %g1 + 0x21 ], %l1 <== NOT EXECUTED
400207d4: e0 08 60 22 ldub [ %g1 + 0x22 ], %l0 <== NOT EXECUTED
400207d8: ee 08 60 23 ldub [ %g1 + 0x23 ], %l7 <== NOT EXECUTED
400207dc: 7f ff c7 83 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
400207e0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rc > 0)
400207e4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400207e8: 34 bf ff d4 bg,a 40020738 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400207ec: 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);
400207f0: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
400207f4: 7f ff f0 d5 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
400207f8: 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);
400207fc: 7f ff b1 8a call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40020800: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020804: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40020808: 12 80 00 2d bne 400208bc <rtems_rfs_rtems_device_open+0x1d8><== NOT EXECUTED
4002080c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020810: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
40020814: a8 0d 20 ff and %l4, 0xff, %l4 <== NOT EXECUTED
40020818: a5 2c a0 18 sll %l2, 0x18, %l2 <== NOT EXECUTED
4002081c: 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);
40020820: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020824: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40020828: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4002082c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40020830: aa 0d 60 ff and %l5, 0xff, %l5 <== NOT EXECUTED
40020834: a6 0c e0 ff and %l3, 0xff, %l3 <== NOT EXECUTED
40020838: ab 2d 60 10 sll %l5, 0x10, %l5 <== NOT EXECUTED
4002083c: a7 2c e0 08 sll %l3, 8, %l3 <== NOT EXECUTED
40020840: 9a 15 80 15 or %l6, %l5, %o5 <== NOT EXECUTED
40020844: a2 0c 60 ff and %l1, 0xff, %l1 <== NOT EXECUTED
40020848: 9a 13 40 14 or %o5, %l4, %o5 <== NOT EXECUTED
4002084c: a3 2c 60 10 sll %l1, 0x10, %l1 <== NOT EXECUTED
40020850: 9a 13 40 13 or %o5, %l3, %o5 <== NOT EXECUTED
40020854: 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;
40020858: da 26 20 2c st %o5, [ %i0 + 0x2c ] <== NOT EXECUTED
4002085c: 98 13 00 17 or %o4, %l7, %o4 <== NOT EXECUTED
40020860: a0 0c 20 ff and %l0, 0xff, %l0 <== NOT EXECUTED
40020864: a1 2c 20 08 sll %l0, 8, %l0 <== NOT EXECUTED
40020868: 98 13 00 10 or %o4, %l0, %o4 <== NOT EXECUTED
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
4002086c: 40 00 04 b3 call 40021b38 <rtems_deviceio_open> <== NOT EXECUTED
40020870: d8 26 20 30 st %o4, [ %i0 + 0x30 ] <== NOT EXECUTED
}
40020874: 81 c7 e0 08 ret <== NOT EXECUTED
40020878: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4002087c: 7f ff cd 8a call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020880: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020884: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020888: 02 bf ff b3 be 40020754 <rtems_rfs_rtems_device_open+0x70><== NOT EXECUTED
4002088c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020890: 7f ff db e0 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020894: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020898: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4002089c: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400208a0: 40 00 0d b7 call 40023f7c <printf> <== NOT EXECUTED
400208a4: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_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);
400208a8: 40 00 08 24 call 40022938 <__errno> <== NOT EXECUTED
400208ac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400208b0: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400208b4: 81 c7 e0 08 ret <== NOT EXECUTED
400208b8: 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))
400208bc: 7f ff cd 7a call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400208c0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400208c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400208c8: 22 bf ff d3 be,a 40020814 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
400208cc: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400208d0: 7f ff db d0 call 40017810 <rtems_status_text> <== NOT EXECUTED
400208d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400208d8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400208dc: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400208e0: 40 00 0d a7 call 40023f7c <printf> <== NOT EXECUTED
400208e4: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400208e8: 10 bf ff cb b 40020814 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
400208ec: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
400206bc <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);
400206bc: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
400206c0: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
400206c4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400206c8: 40 00 05 35 call 40021b9c <rtems_deviceio_read> <== NOT EXECUTED
400206cc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400206a8 <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);
400206a8: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
400206ac: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
400206b0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400206b4: 40 00 05 55 call 40021c08 <rtems_deviceio_write> <== NOT EXECUTED
400206b8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400208f8 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
400208f8: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400208fc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
40020900: 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);
40020904: 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);
40020908: 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
};
4002090c: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40020910: 94 10 20 00 clr %o2
40020914: 7f ff b0 f5 call 4000cce8 <rtems_semaphore_obtain>
40020918: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002091c: b8 92 20 00 orcc %o0, 0, %i4
40020920: 12 80 00 2d bne 400209d4 <rtems_rfs_rtems_dir_open+0xdc> <== NEVER TAKEN
40020924: 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);
40020928: 90 10 00 1d mov %i5, %o0
4002092c: 92 10 00 1b mov %i3, %o1
40020930: 94 07 bf d8 add %fp, -40, %o2
40020934: 7f ff c6 b5 call 40012408 <rtems_rfs_inode_open>
40020938: 96 10 20 01 mov 1, %o3
if (rc)
4002093c: b8 92 20 00 orcc %o0, 0, %i4
40020940: 32 80 00 39 bne,a 40020a24 <rtems_rfs_rtems_dir_open+0x12c><== NEVER TAKEN
40020944: 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);
40020948: c2 07 bf e4 ld [ %fp + -28 ], %g1
4002094c: 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)))
40020950: 03 00 00 3c sethi %hi(0xf000), %g1
40020954: 85 28 a0 08 sll %g2, 8, %g2
40020958: 84 08 80 01 and %g2, %g1, %g2
4002095c: 03 00 00 10 sethi %hi(0x4000), %g1
40020960: 80 a0 80 01 cmp %g2, %g1
40020964: 12 80 00 48 bne 40020a84 <rtems_rfs_rtems_dir_open+0x18c> <== NEVER TAKEN
40020968: 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);
4002096c: 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;
40020970: c0 26 20 08 clr [ %i0 + 8 ]
rtems_rfs_inode_close (fs, &inode);
40020974: 7f ff c7 1d call 400125e8 <rtems_rfs_inode_close>
40020978: 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);
4002097c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
40020980: 7f ff f0 72 call 4001cb48 <rtems_rfs_buffers_release>
40020984: 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);
40020988: 7f ff b1 27 call 4000ce24 <rtems_semaphore_release>
4002098c: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020990: ba 92 20 00 orcc %o0, 0, %i5
40020994: 12 80 00 04 bne 400209a4 <rtems_rfs_rtems_dir_open+0xac> <== NEVER TAKEN
40020998: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
}
4002099c: 81 c7 e0 08 ret
400209a0: 91 e8 20 00 restore %g0, 0, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400209a4: 7f ff cd 40 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400209a8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400209ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400209b0: 02 bf ff fb be 4002099c <rtems_rfs_rtems_dir_open+0xa4> <== NOT EXECUTED
400209b4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400209b8: 7f ff db 96 call 40017810 <rtems_status_text> <== NOT EXECUTED
400209bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400209c0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400209c4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400209c8: 40 00 0d 6d call 40023f7c <printf> <== NOT EXECUTED
400209cc: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400209d0: 30 bf ff f3 b,a 4002099c <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))
400209d4: 7f ff cd 34 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400209d8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400209dc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400209e0: 22 bf ff d3 be,a 4002092c <rtems_rfs_rtems_dir_open+0x34><== NOT EXECUTED
400209e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400209e8: 7f ff db 8a call 40017810 <rtems_status_text> <== NOT EXECUTED
400209ec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400209f0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400209f4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400209f8: 40 00 0d 61 call 40023f7c <printf> <== NOT EXECUTED
400209fc: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
40020a00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020a04: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40020a08: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40020a0c: 7f ff c6 7f call 40012408 <rtems_rfs_inode_open> <== NOT EXECUTED
40020a10: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40020a14: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40020a18: 02 bf ff cd be 4002094c <rtems_rfs_rtems_dir_open+0x54> <== NOT EXECUTED
40020a1c: 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);
40020a20: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40020a24: 7f ff f0 49 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40020a28: 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);
40020a2c: 7f ff b0 fe call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40020a30: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020a34: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40020a38: 12 80 00 07 bne 40020a54 <rtems_rfs_rtems_dir_open+0x15c> <== NOT EXECUTED
40020a3c: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
40020a40: 40 00 07 be call 40022938 <__errno> <== NOT EXECUTED
40020a44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020a48: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40020a4c: 81 c7 e0 08 ret <== NOT EXECUTED
40020a50: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020a54: 7f ff cd 14 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020a58: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020a5c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020a60: 02 bf ff f8 be 40020a40 <rtems_rfs_rtems_dir_open+0x148> <== NOT EXECUTED
40020a64: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020a68: 7f ff db 6a call 40017810 <rtems_status_text> <== NOT EXECUTED
40020a6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020a70: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020a74: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020a78: 40 00 0d 41 call 40023f7c <printf> <== NOT EXECUTED
40020a7c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020a80: 30 bf ff f0 b,a 40020a40 <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);
40020a84: 7f ff c6 d9 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020a88: 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);
40020a8c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40020a90: 7f ff f0 2e call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40020a94: 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);
40020a98: 7f ff b0 e3 call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40020a9c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020aa0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40020aa4: 12 80 00 08 bne 40020ac4 <rtems_rfs_rtems_dir_open+0x1cc> <== NOT EXECUTED
40020aa8: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
40020aac: 40 00 07 a3 call 40022938 <__errno> <== NOT EXECUTED
40020ab0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020ab4: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
40020ab8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40020abc: 81 c7 e0 08 ret <== NOT EXECUTED
40020ac0: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020ac4: 7f ff cc f8 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020ac8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020acc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020ad0: 02 bf ff f7 be 40020aac <rtems_rfs_rtems_dir_open+0x1b4> <== NOT EXECUTED
40020ad4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020ad8: 7f ff db 4e call 40017810 <rtems_status_text> <== NOT EXECUTED
40020adc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020ae0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020ae4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020ae8: 40 00 0d 25 call 40023f7c <printf> <== NOT EXECUTED
40020aec: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020af0: 30 bf ff ef b,a 40020aac <rtems_rfs_rtems_dir_open+0x1b4><== NOT EXECUTED
40020af4 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
40020af4: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40020af8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
40020afc: 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);
40020b00: 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);
40020b04: 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
};
40020b08: c2 04 20 80 ld [ %l0 + 0x80 ], %g1
40020b0c: 94 10 20 00 clr %o2
40020b10: 7f ff b0 76 call 4000cce8 <rtems_semaphore_obtain>
40020b14: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020b18: ba 92 20 00 orcc %o0, 0, %i5
40020b1c: 12 80 00 41 bne 40020c20 <rtems_rfs_rtems_dir_read+0x12c> <== NEVER TAKEN
40020b20: 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);
40020b24: 92 10 00 1c mov %i4, %o1
40020b28: 90 10 00 10 mov %l0, %o0
40020b2c: 94 07 bf d8 add %fp, -40, %o2
40020b30: 7f ff c6 36 call 40012408 <rtems_rfs_inode_open>
40020b34: 96 10 20 01 mov 1, %o3
if (rc)
40020b38: b8 92 20 00 orcc %o0, 0, %i4
40020b3c: 32 80 00 4d bne,a 40020c70 <rtems_rfs_rtems_dir_read+0x17c><== NEVER TAKEN
40020b40: 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);
40020b44: 90 10 00 1a mov %i2, %o0
40020b48: 92 10 21 18 mov 0x118, %o1
40020b4c: 7f ff 86 d5 call 400026a0 <.udiv>
40020b50: 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++)
40020b54: b4 92 20 00 orcc %o0, 0, %i2
40020b58: 02 80 00 1a be 40020bc0 <rtems_rfs_rtems_dir_read+0xcc> <== NEVER TAKEN
40020b5c: 92 07 bf d8 add %fp, -40, %o1
40020b60: 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,
40020b64: b6 10 20 00 clr %i3
40020b68: 10 80 00 0d b 40020b9c <rtems_rfs_rtems_dir_read+0xa8>
40020b6c: ba 10 20 00 clr %i5
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
40020b70: 80 a2 20 00 cmp %o0, 0
40020b74: 14 80 00 4b bg 40020ca0 <rtems_rfs_rtems_dir_read+0x1ac> <== NEVER TAKEN
40020b78: d4 07 bf d4 ld [ %fp + -44 ], %o2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
40020b7c: 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++)
40020b80: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
40020b84: 96 80 c0 0a addcc %g3, %o2, %o3
40020b88: 94 40 a0 00 addx %g2, 0, %o2
40020b8c: 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++)
40020b90: 80 a6 c0 1a cmp %i3, %i2
40020b94: 02 80 00 0a be 40020bbc <rtems_rfs_rtems_dir_read+0xc8> <== ALWAYS TAKEN
40020b98: ba 07 61 18 add %i5, 0x118, %i5
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
40020b9c: 98 06 40 1d add %i1, %i5, %o4
40020ba0: 90 10 00 10 mov %l0, %o0
40020ba4: 92 07 bf d8 add %fp, -40, %o1
40020ba8: 7f ff f3 fe call 4001dba0 <rtems_rfs_dir_read>
40020bac: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
40020bb0: 80 a2 20 02 cmp %o0, 2
40020bb4: 12 bf ff ef bne 40020b70 <rtems_rfs_rtems_dir_read+0x7c>
40020bb8: b8 10 00 08 mov %o0, %i4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
40020bbc: 92 07 bf d8 add %fp, -40, %o1
40020bc0: 7f ff c6 8a call 400125e8 <rtems_rfs_inode_close>
40020bc4: 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);
40020bc8: f8 04 20 80 ld [ %l0 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
40020bcc: 7f ff ef df call 4001cb48 <rtems_rfs_buffers_release>
40020bd0: 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);
40020bd4: 7f ff b0 94 call 4000ce24 <rtems_semaphore_release>
40020bd8: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020bdc: b8 92 20 00 orcc %o0, 0, %i4
40020be0: 12 80 00 04 bne 40020bf0 <rtems_rfs_rtems_dir_read+0xfc> <== NEVER TAKEN
40020be4: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
40020be8: 81 c7 e0 08 ret
40020bec: 91 e8 00 1d restore %g0, %i5, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020bf0: 7f ff cc ad call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020bf4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020bf8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020bfc: 02 bf ff fb be 40020be8 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
40020c00: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020c04: 7f ff db 03 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020c08: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40020c0c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020c10: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020c14: 40 00 0c da call 40023f7c <printf> <== NOT EXECUTED
40020c18: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020c1c: 30 bf ff f3 b,a 40020be8 <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))
40020c20: 7f ff cc a1 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020c24: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020c28: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020c2c: 02 bf ff bf be 40020b28 <rtems_rfs_rtems_dir_read+0x34> <== NOT EXECUTED
40020c30: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40020c34: 7f ff da f7 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020c38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020c3c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020c40: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020c44: 40 00 0c ce call 40023f7c <printf> <== NOT EXECUTED
40020c48: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
40020c4c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40020c50: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40020c54: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40020c58: 7f ff c5 ec call 40012408 <rtems_rfs_inode_open> <== NOT EXECUTED
40020c5c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40020c60: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40020c64: 02 bf ff b9 be 40020b48 <rtems_rfs_rtems_dir_read+0x54> <== NOT EXECUTED
40020c68: 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);
40020c6c: fa 04 20 80 ld [ %l0 + 0x80 ], %i5 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40020c70: 7f ff ef b6 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40020c74: 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);
40020c78: 7f ff b0 6b call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40020c7c: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020c80: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40020c84: 12 80 00 16 bne 40020cdc <rtems_rfs_rtems_dir_read+0x1e8> <== NOT EXECUTED
40020c88: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
40020c8c: 40 00 07 2b call 40022938 <__errno> <== NOT EXECUTED
40020c90: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
40020c94: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
40020c98: 81 c7 e0 08 ret <== NOT EXECUTED
40020c9c: 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);
40020ca0: 40 00 07 26 call 40022938 <__errno> <== NOT EXECUTED
40020ca4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
40020ca8: 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);
40020cac: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
40020cb0: 7f ff c6 4e call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020cb4: 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);
40020cb8: f8 04 20 80 ld [ %l0 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40020cbc: 7f ff ef a3 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40020cc0: 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);
40020cc4: 7f ff b0 58 call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40020cc8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40020ccc: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40020cd0: 02 bf ff c6 be 40020be8 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
40020cd4: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020cd8: 30 bf ff c6 b,a 40020bf0 <rtems_rfs_rtems_dir_read+0xfc> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020cdc: 7f ff cc 72 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020ce0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020ce4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020ce8: 02 bf ff e9 be 40020c8c <rtems_rfs_rtems_dir_read+0x198> <== NOT EXECUTED
40020cec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020cf0: 7f ff da c8 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020cf4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020cf8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020cfc: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020d00: 40 00 0c 9f call 40023f7c <printf> <== NOT EXECUTED
40020d04: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020d08: 30 bf ff e1 b,a 40020c8c <rtems_rfs_rtems_dir_read+0x198><== NOT EXECUTED
40013488 <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)
{
40013488: 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);
4001348c: 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);
40013490: 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);
40013494: 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);
40013498: 94 07 bf d8 add %fp, -40, %o2
4001349c: 90 10 00 1d mov %i5, %o0
400134a0: 7f ff fb da call 40012408 <rtems_rfs_inode_open>
400134a4: 96 10 20 01 mov 1, %o3
if (rc == 0) {
400134a8: b8 92 20 00 orcc %o0, 0, %i4
400134ac: 12 80 00 0e bne 400134e4 <rtems_rfs_rtems_eval_path+0x5c> <== NEVER TAKEN
400134b0: 92 07 bf d8 add %fp, -40, %o1
rtems_filesystem_eval_path_generic (
400134b4: 90 10 00 18 mov %i0, %o0
400134b8: 15 10 00 d8 sethi %hi(0x40036000), %o2
400134bc: 40 00 12 d9 call 40018020 <rtems_filesystem_eval_path_generic>
400134c0: 94 12 a0 00 mov %o2, %o2 ! 40036000 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
400134c4: 90 10 00 1d mov %i5, %o0
400134c8: 7f ff fc 48 call 400125e8 <rtems_rfs_inode_close>
400134cc: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
400134d0: ba 92 20 00 orcc %o0, 0, %i5
400134d4: 12 80 00 0c bne 40013504 <rtems_rfs_rtems_eval_path+0x7c> <== NEVER TAKEN
400134d8: 01 00 00 00 nop
400134dc: 81 c7 e0 08 ret
400134e0: 81 e8 00 00 restore
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
400134e4: 40 00 3d 15 call 40022938 <__errno> <== NOT EXECUTED
400134e8: 01 00 00 00 nop <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
400134ec: 92 10 3f ff mov -1, %o1 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
400134f0: 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 (
400134f4: 7f ff d8 4d call 40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400134f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400134fc: 81 c7 e0 08 ret <== NOT EXECUTED
40013500: 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)
40013504: 40 00 3d 0d call 40022938 <__errno> <== NOT EXECUTED
40013508: 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 (
4001350c: 92 10 3f ff mov -1, %o1 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
40013510: 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 (
40013514: 7f ff d8 45 call 40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013518: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001351c: 81 c7 e0 08 ret <== NOT EXECUTED
40013520: 81 e8 00 00 restore <== NOT EXECUTED
40013830 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40013830: 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);
40013834: 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(
40013838: 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;
4001383c: 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;
40013840: 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);
40013844: 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;
40013848: d6 08 60 07 ldub [ %g1 + 7 ], %o3
4001384c: 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;
40013850: 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;
40013854: 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);
40013858: 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;
4001385c: 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;
40013860: 96 10 c0 0b or %g3, %o3, %o3
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40013864: 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;
40013868: 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(
4001386c: 97 2a e0 10 sll %o3, 0x10, %o3
40013870: 98 13 00 02 or %o4, %g2, %o4
40013874: 92 10 20 01 mov 1, %o1
40013878: 94 12 80 01 or %o2, %g1, %o2
4001387c: 97 32 e0 10 srl %o3, 0x10, %o3
40013880: 99 33 20 10 srl %o4, 0x10, %o4
40013884: 40 00 11 da call 40017fec <rtems_filesystem_eval_path_check_access>
40013888: 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) {
4001388c: 80 8a 20 ff btst 0xff, %o0
40013890: 02 80 00 39 be 40013974 <rtems_rfs_rtems_eval_token+0x144>
40013894: 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] == '.';
40013898: 22 80 00 39 be,a 4001397c <rtems_rfs_rtems_eval_token+0x14c>
4001389c: 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);
400138a0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
400138a4: 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);
400138a8: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
400138ac: 94 10 00 1a mov %i2, %o2
400138b0: 90 10 00 1c mov %i4, %o0
400138b4: 96 10 00 1b mov %i3, %o3
400138b8: 98 07 bf f4 add %fp, -12, %o4
400138bc: 40 00 25 4b call 4001cde8 <rtems_rfs_dir_lookup_ino>
400138c0: 9a 07 bf f8 add %fp, -8, %o5
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
400138c4: 80 a2 20 00 cmp %o0, 0
400138c8: 12 80 00 2b bne 40013974 <rtems_rfs_rtems_eval_token+0x144>
400138cc: b0 10 20 02 mov 2, %i0
rc = rtems_rfs_inode_close (fs, inode);
400138d0: 90 10 00 1c mov %i4, %o0
400138d4: 7f ff fb 45 call 400125e8 <rtems_rfs_inode_close>
400138d8: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
400138dc: 80 a2 20 00 cmp %o0, 0
400138e0: 12 80 00 2d bne 40013994 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
400138e4: 90 10 00 19 mov %i1, %o0
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
400138e8: d2 07 bf f4 ld [ %fp + -12 ], %o1
400138ec: 90 10 00 1c mov %i4, %o0
400138f0: 94 10 00 19 mov %i1, %o2
400138f4: 7f ff fa c5 call 40012408 <rtems_rfs_inode_open>
400138f8: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
400138fc: 80 a2 20 00 cmp %o0, 0
40013900: 12 80 00 25 bne 40013994 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
40013904: 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)
40013908: 7f ff fd 0a call 40012d30 <rtems_rfs_rtems_node_type_by_inode>
4001390c: 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);
40013910: 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;
40013914: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40013918: 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;
4001391c: c0 27 60 0c clr [ %i5 + 0xc ]
40013920: 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;
40013924: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40013928: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
4001392c: 80 a2 20 03 cmp %o0, 3
40013930: 12 80 00 07 bne 4001394c <rtems_rfs_rtems_eval_token+0x11c>
40013934: 84 08 a0 01 and %g2, 1, %g2
40013938: 80 a0 60 00 cmp %g1, 0
4001393c: 02 80 00 25 be 400139d0 <rtems_rfs_rtems_eval_token+0x1a0>
40013940: 80 88 a0 ff btst 0xff, %g2
40013944: 12 80 00 24 bne 400139d4 <rtems_rfs_rtems_eval_token+0x1a4>
40013948: 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;
4001394c: 90 07 60 18 add %i5, 0x18, %o0
40013950: 40 00 01 16 call 40013da8 <rtems_rfs_rtems_set_handlers>
40013954: 92 10 00 19 mov %i1, %o1
40013958: 80 8a 20 ff btst 0xff, %o0
4001395c: 02 80 00 14 be 400139ac <rtems_rfs_rtems_eval_token+0x17c><== NEVER TAKEN
40013960: c2 07 bf f4 ld [ %fp + -12 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40013964: 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);
40013968: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
4001396c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40013970: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
40013974: 81 c7 e0 08 ret
40013978: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
4001397c: 80 a0 60 2e cmp %g1, 0x2e
40013980: 32 bf ff c9 bne,a 400138a4 <rtems_rfs_rtems_eval_token+0x74>
40013984: 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;
40013988: c0 27 60 0c clr [ %i5 + 0xc ]
4001398c: 81 c7 e0 08 ret
40013990: 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));
40013994: 92 10 20 00 clr %o1 <== NOT EXECUTED
40013998: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
4001399c: 40 00 40 fa call 40023d84 <memset> <== NOT EXECUTED
400139a0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
400139a4: 81 c7 e0 08 ret <== NOT EXECUTED
400139a8: 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)
400139ac: 40 00 3b e3 call 40022938 <__errno> <== NOT EXECUTED
400139b0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
400139b4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
400139b8: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
400139bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
400139c0: 7f ff d7 1a call 40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400139c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400139c8: 81 c7 e0 08 ret <== NOT EXECUTED
400139cc: 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;
400139d0: 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);
400139d4: 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);
400139d8: 90 10 24 01 mov 0x401, %o0
400139dc: 7f ff d2 f8 call 400085bc <malloc>
400139e0: c2 27 bf fc st %g1, [ %fp + -4 ]
if (link != NULL) {
400139e4: b6 92 20 00 orcc %o0, 0, %i3
400139e8: 02 80 00 14 be 40013a38 <rtems_rfs_rtems_eval_token+0x208><== NEVER TAKEN
400139ec: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
400139f0: 92 10 00 1a mov %i2, %o1
400139f4: 94 10 00 1b mov %i3, %o2
400139f8: 96 10 24 00 mov 0x400, %o3
400139fc: 40 00 32 82 call 40020404 <rtems_rfs_symlink_read>
40013a00: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
40013a04: 80 a2 20 00 cmp %o0, 0
40013a08: 12 80 00 09 bne 40013a2c <rtems_rfs_rtems_eval_token+0x1fc><== NEVER TAKEN
40013a0c: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
40013a10: d4 07 bf fc ld [ %fp + -4 ], %o2
40013a14: 7f ff d8 2d call 40009ac8 <rtems_filesystem_eval_path_recursive>
40013a18: 92 10 00 1b mov %i3, %o1
} else {
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
40013a1c: 7f ff d1 4b call 40007f48 <free>
40013a20: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40013a24: 81 c7 e0 08 ret
40013a28: 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);
40013a2c: 7f ff d6 ff call 40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013a30: 92 10 20 00 clr %o1 <== NOT EXECUTED
40013a34: 30 bf ff fa b,a 40013a1c <rtems_rfs_rtems_eval_token+0x1ec><== NOT EXECUTED
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
40013a38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40013a3c: 7f ff d6 fb call 40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013a40: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
40013a44: 30 bf ff f8 b,a 40013a24 <rtems_rfs_rtems_eval_token+0x1f4><== NOT EXECUTED
400131c8 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
400131c8: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400131cc: 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);
400131d0: 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);
400131d4: 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);
400131d8: 94 07 bf d8 add %fp, -40, %o2
400131dc: 90 10 00 1c mov %i4, %o0
400131e0: 7f ff fc 8a call 40012408 <rtems_rfs_inode_open>
400131e4: 96 10 20 01 mov 1, %o3
if (rc)
400131e8: ba 92 20 00 orcc %o0, 0, %i5
400131ec: 12 80 00 24 bne 4001327c <rtems_rfs_rtems_fchmod+0xb4> <== NEVER TAKEN
400131f0: 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);
400131f4: c4 08 60 02 ldub [ %g1 + 2 ], %g2
400131f8: c2 08 60 03 ldub [ %g1 + 3 ], %g1
400131fc: 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();
40013200: 40 00 12 59 call 40017b64 <geteuid>
40013204: 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;
40013208: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4001320c: 91 2a 20 10 sll %o0, 0x10, %o0
40013210: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40013214: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40013218: 85 28 a0 08 sll %g2, 8, %g2
4001321c: 84 10 80 03 or %g2, %g3, %g2
40013220: 85 28 a0 10 sll %g2, 0x10, %g2
40013224: 80 a0 80 08 cmp %g2, %o0
40013228: 02 80 00 05 be 4001323c <rtems_rfs_rtems_fchmod+0x74> <== ALWAYS TAKEN
4001322c: 89 32 20 10 srl %o0, 0x10, %g4
40013230: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40013234: 12 80 00 17 bne 40013290 <rtems_rfs_rtems_fchmod+0xc8> <== NOT EXECUTED
40013238: 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);
4001323c: ba 0f 70 00 and %i5, -4096, %i5
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40013240: b2 0e 6f ff and %i1, 0xfff, %i1
40013244: 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);
40013248: 85 36 60 08 srl %i1, 8, %g2
4001324c: c4 28 60 02 stb %g2, [ %g1 + 2 ]
40013250: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
40013254: 90 10 00 1c mov %i4, %o0
40013258: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001325c: 82 10 20 01 mov 1, %g1
40013260: 92 07 bf d8 add %fp, -40, %o1
40013264: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40013268: 7f ff fc e0 call 400125e8 <rtems_rfs_inode_close>
4001326c: b0 10 20 00 clr %i0
if (rc > 0)
40013270: 80 a2 20 00 cmp %o0, 0
40013274: 04 80 00 05 ble 40013288 <rtems_rfs_rtems_fchmod+0xc0> <== ALWAYS TAKEN
40013278: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
4001327c: 40 00 3d af call 40022938 <__errno> <== NOT EXECUTED
40013280: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013284: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40013288: 81 c7 e0 08 ret
4001328c: 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);
40013290: 7f ff fc d6 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40013294: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
40013298: 40 00 3d a8 call 40022938 <__errno> <== NOT EXECUTED
4001329c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400132a0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400132a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400132a8: 81 c7 e0 08 ret <== NOT EXECUTED
400132ac: 81 e8 00 00 restore <== NOT EXECUTED
40013d74 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
40013d74: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40013d78: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
40013d7c: 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));
40013d80: 40 00 23 4c call 4001cab0 <rtems_rfs_buffer_sync> <== NOT EXECUTED
40013d84: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
40013d88: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013d8c: 02 80 00 05 be 40013da0 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
40013d90: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
40013d94: 40 00 3a e9 call 40022938 <__errno> <== NOT EXECUTED
40013d98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013d9c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
40013da0: 81 c7 e0 08 ret <== NOT EXECUTED
40013da4: 81 e8 00 00 restore <== NOT EXECUTED
40020ef8 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
40020ef8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40020efc: 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);
40020f00: 92 10 20 00 clr %o1
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
40020f04: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40020f08: 94 10 20 00 clr %o2
40020f0c: 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
};
40020f10: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40020f14: 7f ff af 75 call 4000cce8 <rtems_semaphore_obtain>
40020f18: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020f1c: b6 92 20 00 orcc %o0, 0, %i3
40020f20: 12 80 00 21 bne 40020fa4 <rtems_rfs_rtems_file_close+0xac><== NEVER TAKEN
40020f24: 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);
40020f28: 90 10 00 1d mov %i5, %o0
40020f2c: 7f ff f5 7e call 4001e524 <rtems_rfs_file_close>
40020f30: 92 10 00 1c mov %i4, %o1
if (rc > 0)
40020f34: b0 92 20 00 orcc %o0, 0, %i0
40020f38: 24 80 00 07 ble,a 40020f54 <rtems_rfs_rtems_file_close+0x5c><== ALWAYS TAKEN
40020f3c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
40020f40: 40 00 06 7e call 40022938 <__errno> <== NOT EXECUTED
40020f44: 01 00 00 00 nop <== NOT EXECUTED
40020f48: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
40020f4c: 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);
40020f50: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40020f54: 7f ff ee fd call 4001cb48 <rtems_rfs_buffers_release>
40020f58: 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);
40020f5c: 7f ff af b2 call 4000ce24 <rtems_semaphore_release>
40020f60: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020f64: ba 92 20 00 orcc %o0, 0, %i5
40020f68: 02 80 00 0d be 40020f9c <rtems_rfs_rtems_file_close+0xa4> <== ALWAYS TAKEN
40020f6c: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020f70: 7f ff cb cd call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020f74: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020f78: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020f7c: 02 80 00 08 be 40020f9c <rtems_rfs_rtems_file_close+0xa4> <== NOT EXECUTED
40020f80: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020f84: 7f ff da 23 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020f88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020f8c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020f90: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020f94: 40 00 0b fa call 40023f7c <printf> <== NOT EXECUTED
40020f98: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rc;
}
40020f9c: 81 c7 e0 08 ret
40020fa0: 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))
40020fa4: 7f ff cb c0 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020fa8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020fac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020fb0: 22 bf ff df be,a 40020f2c <rtems_rfs_rtems_file_close+0x34><== NOT EXECUTED
40020fb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40020fb8: 7f ff da 16 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020fbc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40020fc0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020fc4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020fc8: 40 00 0b ed call 40023f7c <printf> <== NOT EXECUTED
40020fcc: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
40020fd0: 10 bf ff d7 b 40020f2c <rtems_rfs_rtems_file_close+0x34> <== NOT EXECUTED
40020fd4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020fd8 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
40020fd8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40020fdc: 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);
40020fe0: 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));
40020fe4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
40020fe8: 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);
40020fec: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
40020ff0: 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
};
40020ff4: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
40020ff8: b8 10 00 19 mov %i1, %i4
40020ffc: 7f ff af 3b call 4000cce8 <rtems_semaphore_obtain>
40021000: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021004: b4 92 20 00 orcc %o0, 0, %i2
40021008: 12 80 00 23 bne 40021094 <rtems_rfs_rtems_file_ftruncate+0xbc><== NEVER TAKEN
4002100c: 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);
40021010: 90 10 00 1b mov %i3, %o0
40021014: 92 10 00 1c mov %i4, %o1
40021018: 7f ff f7 93 call 4001ee64 <rtems_rfs_file_set_size>
4002101c: 94 10 00 1d mov %i5, %o2
if (rc)
40021020: b0 92 20 00 orcc %o0, 0, %i0
40021024: 22 80 00 07 be,a 40021040 <rtems_rfs_rtems_file_ftruncate+0x68><== ALWAYS TAKEN
40021028: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
4002102c: 40 00 06 43 call 40022938 <__errno> <== NOT EXECUTED
40021030: 01 00 00 00 nop <== NOT EXECUTED
40021034: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
40021038: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002103c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
40021040: 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);
40021044: 7f ff ee c1 call 4001cb48 <rtems_rfs_buffers_release>
40021048: 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);
4002104c: 7f ff af 76 call 4000ce24 <rtems_semaphore_release>
40021050: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021054: ba 92 20 00 orcc %o0, 0, %i5
40021058: 02 80 00 0d be 4002108c <rtems_rfs_rtems_file_ftruncate+0xb4><== ALWAYS TAKEN
4002105c: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021060: 7f ff cb 91 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40021064: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021068: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002106c: 02 80 00 08 be 4002108c <rtems_rfs_rtems_file_ftruncate+0xb4><== NOT EXECUTED
40021070: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021074: 7f ff d9 e7 call 40017810 <rtems_status_text> <== NOT EXECUTED
40021078: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002107c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021080: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40021084: 40 00 0b be call 40023f7c <printf> <== NOT EXECUTED
40021088: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
return rc;
}
4002108c: 81 c7 e0 08 ret
40021090: 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))
40021094: 7f ff cb 84 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40021098: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002109c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400210a0: 22 bf ff dd be,a 40021014 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400210a4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400210a8: 7f ff d9 da call 40017810 <rtems_status_text> <== NOT EXECUTED
400210ac: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400210b0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400210b4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400210b8: 40 00 0b b1 call 40023f7c <printf> <== NOT EXECUTED
400210bc: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
400210c0: 10 bf ff d5 b 40021014 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400210c4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400210c8 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
400210c8: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400210cc: 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);
400210d0: 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));
400210d4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
400210d8: 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);
400210dc: 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)
{
400210e0: 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
};
400210e4: 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)
{
400210e8: ba 10 00 1a mov %i2, %i5
400210ec: d0 00 40 00 ld [ %g1 ], %o0
400210f0: 7f ff ae fe call 4000cce8 <rtems_semaphore_obtain>
400210f4: b2 10 00 1b mov %i3, %i1
if (sc != RTEMS_SUCCESSFUL)
400210f8: b4 92 20 00 orcc %o0, 0, %i2
400210fc: 12 80 00 22 bne 40021184 <rtems_rfs_rtems_file_lseek+0xbc><== NEVER TAKEN
40021100: 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);
40021104: 92 10 00 1c mov %i4, %o1
40021108: 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;
4002110c: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
40021110: 90 10 00 18 mov %i0, %o0
40021114: 40 00 01 99 call 40021778 <rtems_filesystem_default_lseek_file>
40021118: 96 10 00 19 mov %i1, %o3
4002111c: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
40021120: 80 a7 3f ff cmp %i4, -1
40021124: 02 80 00 2d be 400211d8 <rtems_rfs_rtems_file_lseek+0x110>
40021128: ba 10 00 09 mov %o1, %i5
{
rtems_rfs_pos pos = iop->offset;
4002112c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
40021130: 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;
40021134: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
40021138: 92 10 00 02 mov %g2, %o1
4002113c: 94 10 00 03 mov %g3, %o2
40021140: 7f ff f7 06 call 4001ed58 <rtems_rfs_file_seek>
40021144: 96 07 bf f8 add %fp, -8, %o3
if (rc)
40021148: b2 92 20 00 orcc %o0, 0, %i1
4002114c: 12 80 00 30 bne 4002120c <rtems_rfs_rtems_file_lseek+0x144><== NEVER TAKEN
40021150: 01 00 00 00 nop
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40021154: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40021158: 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);
4002115c: 7f ff ee 7b call 4001cb48 <rtems_rfs_buffers_release>
40021160: 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);
40021164: 7f ff af 30 call 4000ce24 <rtems_semaphore_release>
40021168: d0 06 c0 00 ld [ %i3 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002116c: b6 92 20 00 orcc %o0, 0, %i3
40021170: 12 80 00 36 bne 40021248 <rtems_rfs_rtems_file_lseek+0x180><== NEVER TAKEN
40021174: 90 10 20 00 clr %o0
return new_offset;
}
40021178: b0 10 00 1c mov %i4, %i0
4002117c: 81 c7 e0 08 ret
40021180: 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))
40021184: 7f ff cb 48 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40021188: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002118c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021190: 02 bf ff de be 40021108 <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
40021194: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40021198: 7f ff d9 9e call 40017810 <rtems_status_text> <== NOT EXECUTED
4002119c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400211a0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400211a4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400211a8: 40 00 0b 75 call 40023f7c <printf> <== NOT EXECUTED
400211ac: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
400211b0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400211b4: 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;
400211b8: f4 1e 20 08 ldd [ %i0 + 8 ], %i2 <== NOT EXECUTED
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
400211bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400211c0: 40 00 01 6e call 40021778 <rtems_filesystem_default_lseek_file><== NOT EXECUTED
400211c4: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
400211c8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
if (new_offset != -1)
400211cc: 80 a7 3f ff cmp %i4, -1 <== NOT EXECUTED
400211d0: 12 bf ff d7 bne 4002112c <rtems_rfs_rtems_file_lseek+0x64><== NOT EXECUTED
400211d4: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
400211d8: 80 a2 7f ff cmp %o1, -1
400211dc: 22 bf ff df be,a 40021158 <rtems_rfs_rtems_file_lseek+0x90><== ALWAYS TAKEN
400211e0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
400211e4: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
400211e8: 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;
400211ec: c4 3f bf f8 std %g2, [ %fp + -8 ] <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
400211f0: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
400211f4: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
400211f8: 7f ff f6 d8 call 4001ed58 <rtems_rfs_file_seek> <== NOT EXECUTED
400211fc: 96 07 bf f8 add %fp, -8, %o3 <== NOT EXECUTED
if (rc)
40021200: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
40021204: 22 bf ff d5 be,a 40021158 <rtems_rfs_rtems_file_lseek+0x90><== NOT EXECUTED
40021208: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
4002120c: 40 00 05 cb call 40022938 <__errno> <== NOT EXECUTED
40021210: 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));
40021214: 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);
40021218: 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));
4002121c: 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;
40021220: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
40021224: 7f ff ee 49 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40021228: 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);
4002122c: 7f ff ae fe call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
40021230: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
new_offset = -1;
40021234: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021238: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
4002123c: 02 bf ff cf be 40021178 <rtems_rfs_rtems_file_lseek+0xb0> <== NOT EXECUTED
40021240: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021244: 90 10 20 00 clr %o0 <== NOT EXECUTED
40021248: 7f ff cb 17 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4002124c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021250: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021254: 22 bf ff ca be,a 4002117c <rtems_rfs_rtems_file_lseek+0xb4><== NOT EXECUTED
40021258: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
4002125c: 7f ff d9 6d call 40017810 <rtems_status_text> <== NOT EXECUTED
40021260: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return new_offset;
}
40021264: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
40021268: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4002126c: b2 10 00 1d mov %i5, %i1 <== NOT EXECUTED
40021270: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40021274: 40 00 0b 42 call 40023f7c <printf> <== NOT EXECUTED
40021278: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
4002127c: 81 c7 e0 08 ret <== NOT EXECUTED
40021280: 81 e8 00 00 restore <== NOT EXECUTED
40021284 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
40021284: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021288: 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);
4002128c: 92 10 20 00 clr %o1
40021290: fa 00 60 08 ld [ %g1 + 8 ], %i5
40021294: 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
};
40021298: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
4002129c: 7f ff ae 93 call 4000cce8 <rtems_semaphore_obtain>
400212a0: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
400212a4: b8 92 20 00 orcc %o0, 0, %i4
400212a8: 12 80 00 23 bne 40021334 <rtems_rfs_rtems_file_open+0xb0> <== NEVER TAKEN
400212ac: 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);
400212b0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
400212b4: 90 10 00 1d mov %i5, %o0
400212b8: 94 10 20 00 clr %o2
400212bc: 7f ff f3 c9 call 4001e1e0 <rtems_rfs_file_open>
400212c0: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
400212c4: b8 92 20 00 orcc %o0, 0, %i4
400212c8: 04 80 00 2f ble 40021384 <rtems_rfs_rtems_file_open+0x100><== ALWAYS TAKEN
400212cc: 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);
400212d0: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
400212d4: 7f ff ee 1d call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
400212d8: 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);
400212dc: 7f ff ae d2 call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
400212e0: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
400212e4: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400212e8: 12 80 00 07 bne 40021304 <rtems_rfs_rtems_file_open+0x80> <== NOT EXECUTED
400212ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("file-open: open", rc);
400212f0: 40 00 05 92 call 40022938 <__errno> <== NOT EXECUTED
400212f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400212f8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400212fc: 81 c7 e0 08 ret <== NOT EXECUTED
40021300: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021304: 7f ff ca e8 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40021308: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002130c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021310: 02 bf ff f8 be 400212f0 <rtems_rfs_rtems_file_open+0x6c> <== NOT EXECUTED
40021314: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021318: 7f ff d9 3e call 40017810 <rtems_status_text> <== NOT EXECUTED
4002131c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021320: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021324: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40021328: 40 00 0b 15 call 40023f7c <printf> <== NOT EXECUTED
4002132c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021330: 30 bf ff f0 b,a 400212f0 <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))
40021334: 7f ff ca dc call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40021338: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002133c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021340: 22 bf ff dd be,a 400212b4 <rtems_rfs_rtems_file_open+0x30><== NOT EXECUTED
40021344: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40021348: 7f ff d9 32 call 40017810 <rtems_status_text> <== NOT EXECUTED
4002134c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40021350: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021354: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40021358: 40 00 0b 09 call 40023f7c <printf> <== NOT EXECUTED
4002135c: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
40021360: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
40021364: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021368: 94 10 20 00 clr %o2 <== NOT EXECUTED
4002136c: 7f ff f3 9d call 4001e1e0 <rtems_rfs_file_open> <== NOT EXECUTED
40021370: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
if (rc > 0)
40021374: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40021378: 34 bf ff d7 bg,a 400212d4 <rtems_rfs_rtems_file_open+0x50><== NOT EXECUTED
4002137c: 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);
40021380: 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);
40021384: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
40021388: 90 10 00 1d mov %i5, %o0
4002138c: 7f ff ed ef call 4001cb48 <rtems_rfs_buffers_release>
40021390: 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);
40021394: 7f ff ae a4 call 4000ce24 <rtems_semaphore_release>
40021398: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002139c: ba 92 20 00 orcc %o0, 0, %i5
400213a0: 12 80 00 04 bne 400213b0 <rtems_rfs_rtems_file_open+0x12c><== NEVER TAKEN
400213a4: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
}
400213a8: 81 c7 e0 08 ret
400213ac: 91 e8 20 00 restore %g0, 0, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400213b0: 7f ff ca bd call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400213b4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400213b8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400213bc: 02 bf ff fb be 400213a8 <rtems_rfs_rtems_file_open+0x124> <== NOT EXECUTED
400213c0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400213c4: 7f ff d9 13 call 40017810 <rtems_status_text> <== NOT EXECUTED
400213c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400213cc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400213d0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400213d4: 40 00 0a ea call 40023f7c <printf> <== NOT EXECUTED
400213d8: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400213dc: 30 bf ff f3 b,a 400213a8 <rtems_rfs_rtems_file_open+0x124><== NOT EXECUTED
40020d0c <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
40020d0c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40020d10: 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);
40020d14: 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));
40020d18: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40020d1c: 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);
40020d20: 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)
{
40020d24: 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
};
40020d28: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
40020d2c: 7f ff af ef call 4000cce8 <rtems_semaphore_obtain>
40020d30: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020d34: ba 92 20 00 orcc %o0, 0, %i5
40020d38: 12 80 00 5b bne 40020ea4 <rtems_rfs_rtems_file_read+0x198><== NEVER TAKEN
40020d3c: 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))
40020d40: 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;
40020d44: f8 1c 60 08 ldd [ %l1 + 8 ], %i4
40020d48: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
40020d4c: 7f ff ea 1b call 4001b5b8 <rtems_rfs_block_get_size>
40020d50: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
40020d54: 80 a2 00 1c cmp %o0, %i4
40020d58: 18 80 00 19 bgu 40020dbc <rtems_rfs_rtems_file_read+0xb0> <== NEVER TAKEN
40020d5c: 80 a6 a0 00 cmp %i2, 0
40020d60: 80 a2 00 1c cmp %o0, %i4
40020d64: 02 80 00 13 be 40020db0 <rtems_rfs_rtems_file_read+0xa4> <== ALWAYS TAKEN
40020d68: 80 a2 40 1d cmp %o1, %i5
{
while (count)
40020d6c: 84 10 20 00 clr %g2 <== NOT EXECUTED
40020d70: 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;
40020d74: b0 10 20 00 clr %i0
}
}
}
if (read >= 0)
iop->offset = pos + read;
40020d78: b6 80 c0 1d addcc %g3, %i5, %i3
40020d7c: b4 40 80 1c addx %g2, %i4, %i2
40020d80: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40020d84: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40020d88: 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);
40020d8c: 7f ff ef 6f call 4001cb48 <rtems_rfs_buffers_release>
40020d90: 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);
40020d94: 7f ff b0 24 call 4000ce24 <rtems_semaphore_release>
40020d98: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40020d9c: ba 92 20 00 orcc %o0, 0, %i5
40020da0: 12 80 00 2f bne 40020e5c <rtems_rfs_rtems_file_read+0x150><== NEVER TAKEN
40020da4: 90 10 20 00 clr %o0
return read;
}
40020da8: 81 c7 e0 08 ret
40020dac: 81 e8 00 00 restore
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
40020db0: 08 bf ff f0 bleu 40020d70 <rtems_rfs_rtems_file_read+0x64>
40020db4: 84 10 20 00 clr %g2
{
while (count)
40020db8: 80 a6 a0 00 cmp %i2, 0
40020dbc: 02 bf ff ec be 40020d6c <rtems_rfs_rtems_file_read+0x60> <== NEVER TAKEN
40020dc0: b0 10 20 00 clr %i0
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
40020dc4: 10 80 00 16 b 40020e1c <rtems_rfs_rtems_file_read+0x110>
40020dc8: 92 07 bf fc add %fp, -4, %o1
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
40020dcc: c4 04 20 0c ld [ %l0 + 0xc ], %g2
40020dd0: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
40020dd4: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
40020dd8: 90 10 00 19 mov %i1, %o0
40020ddc: 92 02 40 01 add %o1, %g1, %o1
40020de0: 40 00 0b 5a call 40023b48 <memcpy>
40020de4: 94 10 00 1b mov %i3, %o2
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
40020de8: 90 10 00 10 mov %l0, %o0
40020dec: 92 10 00 1b mov %i3, %o1
40020df0: 94 10 20 01 mov 1, %o2
40020df4: 7f ff f7 1f call 4001ea70 <rtems_rfs_file_io_end>
40020df8: b2 06 40 1b add %i1, %i3, %i1
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
40020dfc: b0 06 c0 18 add %i3, %i0, %i0
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
40020e00: 80 a2 20 00 cmp %o0, 0
40020e04: 14 80 00 39 bg 40020ee8 <rtems_rfs_rtems_file_read+0x1dc> <== NEVER TAKEN
40020e08: a4 10 00 08 mov %o0, %l2
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
40020e0c: 80 a6 a0 00 cmp %i2, 0
40020e10: 02 80 00 21 be 40020e94 <rtems_rfs_rtems_file_read+0x188>
40020e14: 80 a6 20 00 cmp %i0, 0
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
40020e18: 92 07 bf fc add %fp, -4, %o1
40020e1c: 94 10 20 01 mov 1, %o2
40020e20: 7f ff f6 83 call 4001e82c <rtems_rfs_file_io_start>
40020e24: 90 10 00 10 mov %l0, %o0
if (rc > 0)
40020e28: b6 92 20 00 orcc %o0, 0, %i3
40020e2c: 14 80 00 2b bg 40020ed8 <rtems_rfs_rtems_file_read+0x1cc> <== NEVER TAKEN
40020e30: 01 00 00 00 nop
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
40020e34: f6 07 bf fc ld [ %fp + -4 ], %i3
40020e38: 80 a6 e0 00 cmp %i3, 0
40020e3c: 02 80 00 15 be 40020e90 <rtems_rfs_rtems_file_read+0x184>
40020e40: 80 a6 c0 1a cmp %i3, %i2
break;
if (size > count)
40020e44: 28 bf ff e2 bleu,a 40020dcc <rtems_rfs_rtems_file_read+0xc0>
40020e48: b4 26 80 1b sub %i2, %i3, %i2
size = count;
40020e4c: b6 10 00 1a mov %i2, %i3
40020e50: f4 27 bf fc st %i2, [ %fp + -4 ]
40020e54: 10 bf ff de b 40020dcc <rtems_rfs_rtems_file_read+0xc0>
40020e58: b4 10 20 00 clr %i2
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40020e5c: 7f ff cc 12 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020e60: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020e64: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020e68: 02 80 00 08 be 40020e88 <rtems_rfs_rtems_file_read+0x17c> <== NOT EXECUTED
40020e6c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40020e70: 7f ff da 68 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020e74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020e78: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020e7c: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020e80: 40 00 0c 3f call 40023f7c <printf> <== NOT EXECUTED
40020e84: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
iop->offset = pos + read;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return read;
}
40020e88: 81 c7 e0 08 ret <== NOT EXECUTED
40020e8c: 81 e8 00 00 restore <== NOT EXECUTED
break;
}
}
}
if (read >= 0)
40020e90: 80 a6 20 00 cmp %i0, 0
40020e94: 06 bf ff bc bl 40020d84 <rtems_rfs_rtems_file_read+0x78> <== NEVER TAKEN
40020e98: 86 10 00 18 mov %i0, %g3
40020e9c: 10 bf ff b7 b 40020d78 <rtems_rfs_rtems_file_read+0x6c>
40020ea0: 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))
40020ea4: 7f ff cc 00 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40020ea8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40020eac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020eb0: 22 bf ff a5 be,a 40020d44 <rtems_rfs_rtems_file_read+0x38><== NOT EXECUTED
40020eb4: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40020eb8: 7f ff da 56 call 40017810 <rtems_status_text> <== NOT EXECUTED
40020ebc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020ec0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40020ec4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40020ec8: 40 00 0c 2d call 40023f7c <printf> <== NOT EXECUTED
40020ecc: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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))
40020ed0: 10 bf ff 9d b 40020d44 <rtems_rfs_rtems_file_read+0x38> <== NOT EXECUTED
40020ed4: 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);
40020ed8: 40 00 06 98 call 40022938 <__errno> <== NOT EXECUTED
40020edc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020ee0: 10 bf ff a9 b 40020d84 <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED
40020ee4: 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);
40020ee8: 40 00 06 94 call 40022938 <__errno> <== NOT EXECUTED
40020eec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020ef0: 10 bf ff a5 b 40020d84 <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED
40020ef4: e4 22 00 00 st %l2, [ %o0 ] <== NOT EXECUTED
400213e0 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
400213e0: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400213e4: 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);
400213e8: 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));
400213ec: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
400213f0: 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);
400213f4: 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
};
400213f8: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
400213fc: 7f ff ae 3b call 4000cce8 <rtems_semaphore_obtain>
40021400: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021404: ba 92 20 00 orcc %o0, 0, %i5
40021408: 12 80 00 70 bne 400215c8 <rtems_rfs_rtems_file_write+0x1e8><== NEVER TAKEN
4002140c: 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);
40021410: 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;
40021414: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40021418: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4002141c: c4 3f bf f8 std %g2, [ %fp + -8 ]
40021420: 7f ff e8 66 call 4001b5b8 <rtems_rfs_block_get_size>
40021424: 92 02 60 84 add %o1, 0x84, %o1
40021428: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
4002142c: d2 07 bf f8 ld [ %fp + -8 ], %o1
40021430: 84 10 00 08 mov %o0, %g2
40021434: 80 a2 40 02 cmp %o1, %g2
40021438: 18 80 00 7b bgu 40021624 <rtems_rfs_rtems_file_write+0x244><== NEVER TAKEN
4002143c: d4 07 bf fc ld [ %fp + -4 ], %o2
40021440: 80 a2 40 02 cmp %o1, %g2
40021444: 02 80 00 8b be 40021670 <rtems_rfs_rtems_file_write+0x290><== ALWAYS TAKEN
40021448: 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)
4002144c: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED
40021450: 08 80 00 3b bleu 4002153c <rtems_rfs_rtems_file_write+0x15c><== ALWAYS TAKEN
40021454: 01 00 00 00 nop
40021458: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
4002145c: 80 88 62 00 btst 0x200, %g1
40021460: 32 80 00 8d bne,a 40021694 <rtems_rfs_rtems_file_write+0x2b4>
40021464: 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)
40021468: a2 10 20 00 clr %l1
4002146c: 84 10 20 00 clr %g2
40021470: 80 a6 a0 00 cmp %i2, 0
40021474: 12 80 00 1b bne 400214e0 <rtems_rfs_rtems_file_write+0x100><== ALWAYS TAKEN
40021478: 86 10 20 00 clr %g3
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002147c: 10 80 00 3b b 40021568 <rtems_rfs_rtems_file_write+0x188> <== NOT EXECUTED
40021480: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
40021484: d4 07 bf f4 ld [ %fp + -12 ], %o2
40021488: 80 a2 80 1a cmp %o2, %i2
4002148c: 28 80 00 05 bleu,a 400214a0 <rtems_rfs_rtems_file_write+0xc0>
40021490: c4 04 20 0c ld [ %l0 + 0xc ], %g2
size = count;
40021494: f4 27 bf f4 st %i2, [ %fp + -12 ]
40021498: 94 10 00 1a mov %i2, %o2
memcpy (rtems_rfs_file_data (file), data, size);
4002149c: c4 04 20 0c ld [ %l0 + 0xc ], %g2
400214a0: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
400214a4: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
400214a8: 40 00 09 a8 call 40023b48 <memcpy>
400214ac: 90 02 00 01 add %o0, %g1, %o0
data += size;
400214b0: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
400214b4: 90 10 00 10 mov %l0, %o0
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
count -= size;
400214b8: b4 26 80 09 sub %i2, %o1, %i2
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
400214bc: b2 06 40 09 add %i1, %o1, %i1
count -= size;
write += size;
400214c0: a2 04 40 09 add %l1, %o1, %l1
rc = rtems_rfs_file_io_end (file, size, false);
400214c4: 7f ff f5 6b call 4001ea70 <rtems_rfs_file_io_end>
400214c8: 94 10 20 00 clr %o2
if (rc)
400214cc: ba 92 20 00 orcc %o0, 0, %i5
400214d0: 12 80 00 0d bne 40021504 <rtems_rfs_rtems_file_write+0x124><== NEVER TAKEN
400214d4: 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)
400214d8: 02 80 00 20 be 40021558 <rtems_rfs_rtems_file_write+0x178>
400214dc: 86 10 00 11 mov %l1, %g3
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
400214e0: 92 07 bf f4 add %fp, -12, %o1
}
}
while (count)
{
size_t size = count;
400214e4: f4 27 bf f4 st %i2, [ %fp + -12 ]
rc = rtems_rfs_file_io_start (file, &size, false);
400214e8: 94 10 20 00 clr %o2
400214ec: 7f ff f4 d0 call 4001e82c <rtems_rfs_file_io_start>
400214f0: 90 10 00 10 mov %l0, %o0
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
400214f4: 92 10 00 19 mov %i1, %o1
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
400214f8: 80 a2 20 00 cmp %o0, 0
400214fc: 02 bf ff e2 be 40021484 <rtems_rfs_rtems_file_write+0xa4>
40021500: 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);
40021504: 40 00 05 0d call 40022938 <__errno>
40021508: a2 10 3f ff mov -1, %l1
4002150c: fa 22 00 00 st %i5, [ %o0 ]
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40021510: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40021514: 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);
40021518: 7f ff ed 8c call 4001cb48 <rtems_rfs_buffers_release>
4002151c: 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);
40021520: 7f ff ae 41 call 4000ce24 <rtems_semaphore_release>
40021524: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021528: ba 92 20 00 orcc %o0, 0, %i5
4002152c: 12 80 00 1b bne 40021598 <rtems_rfs_rtems_file_write+0x1b8><== NEVER TAKEN
40021530: 90 10 20 00 clr %o0
return write;
}
40021534: 81 c7 e0 08 ret
40021538: 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)
4002153c: 12 bf ff cc bne 4002146c <rtems_rfs_rtems_file_write+0x8c><== NEVER TAKEN
40021540: a2 10 20 00 clr %l1
40021544: 80 a0 c0 0a cmp %g3, %o2
40021548: 28 bf ff ca bleu,a 40021470 <rtems_rfs_rtems_file_write+0x90>
4002154c: 84 10 20 00 clr %g2
40021550: 10 bf ff c3 b 4002145c <rtems_rfs_rtems_file_write+0x7c>
40021554: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
40021558: 80 a4 60 00 cmp %l1, 0
4002155c: 06 bf ff ed bl 40021510 <rtems_rfs_rtems_file_write+0x130><== NEVER TAKEN
40021560: 85 3c 60 1f sra %l1, 0x1f, %g2
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40021564: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
break;
}
}
if (write >= 0)
iop->offset = pos + write;
40021568: f8 1f bf f8 ldd [ %fp + -8 ], %i4
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002156c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
break;
}
}
if (write >= 0)
iop->offset = pos + write;
40021570: 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);
40021574: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
40021578: b4 40 80 1c addx %g2, %i4, %i2
rtems_rfs_buffers_release (fs);
4002157c: 7f ff ed 73 call 4001cb48 <rtems_rfs_buffers_release>
40021580: 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);
40021584: 7f ff ae 28 call 4000ce24 <rtems_semaphore_release>
40021588: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002158c: ba 92 20 00 orcc %o0, 0, %i5
40021590: 02 bf ff e9 be 40021534 <rtems_rfs_rtems_file_write+0x154><== ALWAYS TAKEN
40021594: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021598: 7f ff ca 43 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4002159c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400215a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400215a4: 02 bf ff e4 be 40021534 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
400215a8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400215ac: 7f ff d8 99 call 40017810 <rtems_status_text> <== NOT EXECUTED
400215b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400215b4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400215b8: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400215bc: 40 00 0a 70 call 40023f7c <printf> <== NOT EXECUTED
400215c0: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400215c4: 30 bf ff dc b,a 40021534 <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))
400215c8: 7f ff ca 37 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400215cc: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400215d0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400215d4: 22 bf ff 90 be,a 40021414 <rtems_rfs_rtems_file_write+0x34><== NOT EXECUTED
400215d8: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400215dc: 7f ff d8 8d call 40017810 <rtems_status_text> <== NOT EXECUTED
400215e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400215e4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400215e8: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400215ec: 40 00 0a 64 call 40023f7c <printf> <== NOT EXECUTED
400215f0: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_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);
400215f4: 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;
400215f8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
400215fc: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
40021600: c4 3f bf f8 std %g2, [ %fp + -8 ] <== NOT EXECUTED
40021604: 7f ff e7 ed call 4001b5b8 <rtems_rfs_block_get_size> <== NOT EXECUTED
40021608: 92 02 60 84 add %o1, 0x84, %o1 <== NOT EXECUTED
4002160c: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
40021610: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== NOT EXECUTED
40021614: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
40021618: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED
4002161c: 08 bf ff 8a bleu 40021444 <rtems_rfs_rtems_file_write+0x64><== NOT EXECUTED
40021620: 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);
40021624: 7f ff f6 10 call 4001ee64 <rtems_rfs_file_set_size>
40021628: 90 10 00 10 mov %l0, %o0
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002162c: 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);
40021630: ba 10 00 08 mov %o0, %i5
if (rc)
40021634: 80 a7 60 00 cmp %i5, 0
40021638: 02 80 00 11 be 4002167c <rtems_rfs_rtems_file_write+0x29c><== ALWAYS TAKEN
4002163c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
40021640: 7f ff ed 42 call 4001cb48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40021644: 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);
40021648: 7f ff ad f7 call 4000ce24 <rtems_semaphore_release> <== NOT EXECUTED
4002164c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021650: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40021654: 12 80 00 1b bne 400216c0 <rtems_rfs_rtems_file_write+0x2e0><== NOT EXECUTED
40021658: 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);
4002165c: 40 00 04 b7 call 40022938 <__errno> <== NOT EXECUTED
40021660: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
40021664: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
40021668: 81 c7 e0 08 ret <== NOT EXECUTED
4002166c: 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)
40021670: 08 bf ff 78 bleu 40021450 <rtems_rfs_rtems_file_write+0x70>
40021674: 80 a0 80 09 cmp %g2, %o1
40021678: 30 bf ff eb b,a 40021624 <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);
4002167c: d2 07 bf f8 ld [ %fp + -8 ], %o1
40021680: d4 07 bf fc ld [ %fp + -4 ], %o2
40021684: 7f ff e7 9e call 4001b4fc <rtems_rfs_block_get_bpos>
40021688: 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)
4002168c: 10 bf ff 78 b 4002146c <rtems_rfs_rtems_file_write+0x8c>
40021690: 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);
40021694: 90 10 00 10 mov %l0, %o0
40021698: 92 10 00 02 mov %g2, %o1
4002169c: 94 10 00 03 mov %g3, %o2
400216a0: 7f ff f5 ae call 4001ed58 <rtems_rfs_file_seek>
400216a4: 96 07 bf f8 add %fp, -8, %o3
if (rc)
400216a8: ba 92 20 00 orcc %o0, 0, %i5
400216ac: 02 bf ff 70 be 4002146c <rtems_rfs_rtems_file_write+0x8c> <== ALWAYS TAKEN
400216b0: a2 10 20 00 clr %l1
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
400216b4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
400216b8: 10 bf ff e2 b 40021640 <rtems_rfs_rtems_file_write+0x260> <== NOT EXECUTED
400216bc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400216c0: 7f ff c9 f9 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400216c4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400216c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400216cc: 02 bf ff e4 be 4002165c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
400216d0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400216d4: 7f ff d8 4f call 40017810 <rtems_status_text> <== NOT EXECUTED
400216d8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400216dc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400216e0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400216e4: 40 00 0a 26 call 40023f7c <printf> <== NOT EXECUTED
400216e8: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400216ec: 30 bf ff dc b,a 4002165c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
40013544 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
40013544: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40013548: 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);
4001354c: 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);
40013550: 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);
40013554: 94 07 bf d8 add %fp, -40, %o2
40013558: 90 10 00 1d mov %i5, %o0
4001355c: 7f ff fb ab call 40012408 <rtems_rfs_inode_open>
40013560: 96 10 20 01 mov 1, %o3
if (rc)
40013564: b8 92 20 00 orcc %o0, 0, %i4
40013568: 12 80 00 6f bne 40013724 <rtems_rfs_rtems_fstat+0x1e0> <== NEVER TAKEN
4001356c: 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))
40013570: 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);
40013574: c4 08 60 02 ldub [ %g1 + 2 ], %g2
40013578: d0 08 60 03 ldub [ %g1 + 3 ], %o0
4001357c: 85 28 a0 08 sll %g2, 8, %g2
40013580: 07 00 00 08 sethi %hi(0x2000), %g3
40013584: 88 08 80 04 and %g2, %g4, %g4
40013588: 80 a1 00 03 cmp %g4, %g3
4001358c: 02 80 00 4b be 400136b8 <rtems_rfs_rtems_fstat+0x174> <== NEVER TAKEN
40013590: 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);
40013594: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
40013598: 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);
4001359c: 87 38 60 1f sra %g1, 0x1f, %g3
400135a0: c2 26 60 04 st %g1, [ %i1 + 4 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
400135a4: 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);
400135a8: c6 26 40 00 st %g3, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
400135ac: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = rtems_rfs_rtems_mode (mode);
400135b0: 40 00 02 3b call 40013e9c <rtems_rfs_rtems_mode>
400135b4: 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);
400135b8: c2 07 bf e4 ld [ %fp + -28 ], %g1
400135bc: d0 26 60 0c st %o0, [ %i1 + 0xc ]
400135c0: c6 08 60 01 ldub [ %g1 + 1 ], %g3
400135c4: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
links = 0;
400135c8: 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);
400135cc: 85 28 a0 08 sll %g2, 8, %g2
400135d0: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
400135d4: 87 28 a0 10 sll %g2, 0x10, %g3
400135d8: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
400135dc: 86 39 00 03 xnor %g4, %g3, %g3
400135e0: 80 a0 00 03 cmp %g0, %g3
400135e4: 86 60 20 00 subx %g0, 0, %g3
400135e8: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
400135ec: 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;
400135f0: c4 08 60 06 ldub [ %g1 + 6 ], %g2
400135f4: c6 08 60 07 ldub [ %g1 + 7 ], %g3
400135f8: 85 28 a0 08 sll %g2, 8, %g2
400135fc: 84 10 80 03 or %g2, %g3, %g2
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
40013600: 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;
40013604: c4 08 60 04 ldub [ %g1 + 4 ], %g2
40013608: 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));
4001360c: d2 07 bf e0 ld [ %fp + -32 ], %o1
40013610: 85 28 a0 18 sll %g2, 0x18, %g2
40013614: 83 28 60 10 sll %g1, 0x10, %g1
40013618: 82 10 80 01 or %g2, %g1, %g1
4001361c: 83 30 60 10 srl %g1, 0x10, %g1
40013620: 90 10 00 1d mov %i5, %o0
40013624: 40 00 2e ec call 4001f1d4 <rtems_rfs_file_get_shared>
40013628: c2 36 60 14 sth %g1, [ %i1 + 0x14 ]
if (shared)
4001362c: 92 92 20 00 orcc %o0, 0, %o1
40013630: 02 80 00 42 be 40013738 <rtems_rfs_rtems_fstat+0x1f4>
40013634: 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);
40013638: 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);
4001363c: f8 02 60 8c ld [ %o1 + 0x8c ], %i4
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40013640: c8 02 60 90 ld [ %o1 + 0x90 ], %g4
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40013644: 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))
40013648: 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);
4001364c: 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);
40013650: 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))
40013654: 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);
40013658: 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))
4001365c: 84 08 80 01 and %g2, %g1, %g2
40013660: 03 00 00 28 sethi %hi(0xa000), %g1
40013664: 80 a0 80 01 cmp %g2, %g1
40013668: 02 80 00 2b be 40013714 <rtems_rfs_rtems_fstat+0x1d0> <== NEVER TAKEN
4001366c: 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);
40013670: 90 10 00 1d mov %i5, %o0
40013674: 40 00 1f d1 call 4001b5b8 <rtems_rfs_block_get_size>
40013678: 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);
4001367c: 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);
40013680: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
40013684: 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);
40013688: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
4001368c: 92 07 bf d8 add %fp, -40, %o1
40013690: 7f ff fb d6 call 400125e8 <rtems_rfs_inode_close>
40013694: b0 10 20 00 clr %i0
if (rc > 0)
40013698: 80 a2 20 00 cmp %o0, 0
4001369c: 04 80 00 05 ble 400136b0 <rtems_rfs_rtems_fstat+0x16c> <== ALWAYS TAKEN
400136a0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
400136a4: 40 00 3c a5 call 40022938 <__errno> <== NOT EXECUTED
400136a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400136ac: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
400136b0: 81 c7 e0 08 ret
400136b4: 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]);
400136b8: da 08 60 21 ldub [ %g1 + 0x21 ], %o5 <== NOT EXECUTED
400136bc: c8 08 60 20 ldub [ %g1 + 0x20 ], %g4 <== NOT EXECUTED
400136c0: de 08 60 23 ldub [ %g1 + 0x23 ], %o7 <== NOT EXECUTED
400136c4: f4 08 60 22 ldub [ %g1 + 0x22 ], %i2 <== NOT EXECUTED
400136c8: f6 08 60 1c ldub [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
400136cc: f0 08 60 1d ldub [ %g1 + 0x1d ], %i0 <== NOT EXECUTED
400136d0: f8 08 60 1f ldub [ %g1 + 0x1f ], %i4 <== NOT EXECUTED
400136d4: c6 08 60 1e ldub [ %g1 + 0x1e ], %g3 <== NOT EXECUTED
400136d8: 83 2b 60 10 sll %o5, 0x10, %g1 <== NOT EXECUTED
400136dc: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
400136e0: b5 2e a0 08 sll %i2, 8, %i2 <== NOT EXECUTED
400136e4: 88 11 00 01 or %g4, %g1, %g4 <== NOT EXECUTED
400136e8: b7 2e e0 18 sll %i3, 0x18, %i3 <== NOT EXECUTED
400136ec: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
400136f0: 83 2e 20 10 sll %i0, 0x10, %g1 <== NOT EXECUTED
400136f4: 88 11 00 1a or %g4, %i2, %g4 <== NOT EXECUTED
400136f8: 82 16 c0 01 or %i3, %g1, %g1 <== NOT EXECUTED
400136fc: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
40013700: 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 =
40013704: c8 26 60 1c st %g4, [ %i1 + 0x1c ] <== NOT EXECUTED
40013708: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED
4001370c: 10 bf ff a2 b 40013594 <rtems_rfs_rtems_fstat+0x50> <== NOT EXECUTED
40013710: 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);
40013714: c2 12 60 8a lduh [ %o1 + 0x8a ], %g1 <== NOT EXECUTED
40013718: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
4001371c: 10 bf ff d9 b 40013680 <rtems_rfs_rtems_fstat+0x13c> <== NOT EXECUTED
40013720: 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);
40013724: 40 00 3c 85 call 40022938 <__errno> <== NOT EXECUTED
40013728: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001372c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40013730: 81 c7 e0 08 ret <== NOT EXECUTED
40013734: 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))
40013738: 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);
4001373c: f8 08 60 13 ldub [ %g1 + 0x13 ], %i4
40013740: c4 08 60 10 ldub [ %g1 + 0x10 ], %g2
40013744: f6 08 60 11 ldub [ %g1 + 0x11 ], %i3
40013748: c8 08 60 12 ldub [ %g1 + 0x12 ], %g4
4001374c: b7 2e e0 10 sll %i3, 0x10, %i3
40013750: 89 29 20 08 sll %g4, 8, %g4
40013754: 85 28 a0 18 sll %g2, 0x18, %g2
40013758: 84 10 80 1b or %g2, %i3, %g2
4001375c: 84 10 80 1c or %g2, %i4, %g2
40013760: 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);
40013764: 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);
40013768: f8 08 60 17 ldub [ %g1 + 0x17 ], %i4
4001376c: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
40013770: f6 08 60 15 ldub [ %g1 + 0x15 ], %i3
40013774: c8 08 60 16 ldub [ %g1 + 0x16 ], %g4
40013778: b7 2e e0 10 sll %i3, 0x10, %i3
4001377c: 89 29 20 08 sll %g4, 8, %g4
40013780: 85 28 a0 18 sll %g2, 0x18, %g2
40013784: 84 10 80 1b or %g2, %i3, %g2
40013788: 84 10 80 1c or %g2, %i4, %g2
4001378c: 84 10 80 04 or %g2, %g4, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
40013790: 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);
40013794: f8 08 60 1b ldub [ %g1 + 0x1b ], %i4
40013798: c4 08 60 18 ldub [ %g1 + 0x18 ], %g2
4001379c: f6 08 60 19 ldub [ %g1 + 0x19 ], %i3
400137a0: c8 08 60 1a ldub [ %g1 + 0x1a ], %g4
400137a4: b7 2e e0 10 sll %i3, 0x10, %i3
400137a8: 89 29 20 08 sll %g4, 8, %g4
400137ac: 85 28 a0 18 sll %g2, 0x18, %g2
400137b0: 84 10 80 1b or %g2, %i3, %g2
400137b4: 84 10 80 1c or %g2, %i4, %g2
400137b8: 84 10 80 04 or %g2, %g4, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
400137bc: 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);
400137c0: c4 08 60 0c ldub [ %g1 + 0xc ], %g2
400137c4: f6 08 60 0d ldub [ %g1 + 0xd ], %i3
400137c8: f8 08 60 0f ldub [ %g1 + 0xf ], %i4
400137cc: c8 08 60 0e ldub [ %g1 + 0xe ], %g4
400137d0: 85 28 a0 18 sll %g2, 0x18, %g2
400137d4: b7 2e e0 10 sll %i3, 0x10, %i3
400137d8: 89 29 20 08 sll %g4, 8, %g4
400137dc: 84 10 80 1b or %g2, %i3, %g2
400137e0: 84 10 80 1c or %g2, %i4, %g2
400137e4: 84 10 80 04 or %g2, %g4, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
400137e8: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
400137ec: 05 00 00 3c sethi %hi(0xf000), %g2
400137f0: 86 08 c0 02 and %g3, %g2, %g3
400137f4: 05 00 00 28 sethi %hi(0xa000), %g2
400137f8: 80 a0 c0 02 cmp %g3, %g2
400137fc: 12 80 00 09 bne 40013820 <rtems_rfs_rtems_fstat+0x2dc>
40013800: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
40013804: 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);
40013808: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
4001380c: c0 26 60 20 clr [ %i1 + 0x20 ]
40013810: 83 28 e0 08 sll %g3, 8, %g1
40013814: 82 10 80 01 or %g2, %g1, %g1
40013818: 10 bf ff 9a b 40013680 <rtems_rfs_rtems_fstat+0x13c>
4001381c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
40013820: 7f ff fd 2c call 40012cd0 <rtems_rfs_inode_get_size>
40013824: 92 07 bf d8 add %fp, -40, %o1
40013828: 10 bf ff 96 b 40013680 <rtems_rfs_rtems_fstat+0x13c>
4001382c: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
40013a9c <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
40013a9c: 9d e3 bf 98 save %sp, -104, %sp
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
40013aa0: a2 10 20 05 mov 5, %l1
40013aa4: 80 a6 60 00 cmp %i1, 0
40013aa8: 02 80 00 1f be 40013b24 <rtems_rfs_rtems_initialise+0x88> <== ALWAYS TAKEN
40013aac: ba 10 20 00 clr %i5
{
printf ("options=%s\n", options);
40013ab0: 37 10 00 d7 sethi %hi(0x40035c00), %i3 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40013ab4: 39 10 00 d7 sethi %hi(0x40035c00), %i4 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40013ab8: 35 10 00 d7 sethi %hi(0x40035c00), %i2 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
40013abc: 21 10 00 d7 sethi %hi(0x40035c00), %l0 <== NOT EXECUTED
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
40013ac0: b6 16 e3 18 or %i3, 0x318, %i3 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40013ac4: b8 17 23 28 or %i4, 0x328, %i4 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40013ac8: b4 16 a3 38 or %i2, 0x338, %i2 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
40013acc: a0 14 23 48 or %l0, 0x348, %l0 <== NOT EXECUTED
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
40013ad0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40013ad4: 40 00 41 2a call 40023f7c <printf> <== NOT EXECUTED
40013ad8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40013adc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40013ae0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40013ae4: 40 00 45 c9 call 40025208 <strncmp> <== NOT EXECUTED
40013ae8: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
40013aec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013af0: 12 80 00 1e bne 40013b68 <rtems_rfs_rtems_initialise+0xcc><== NOT EXECUTED
40013af4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
40013af8: 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, ',');
40013afc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40013b00: 40 00 43 48 call 40024820 <strchr> <== NOT EXECUTED
40013b04: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
40013b08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013b0c: 02 80 00 06 be 40013b24 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
40013b10: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
40013b14: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
40013b18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40013b1c: 12 80 00 1b bne 40013b88 <rtems_rfs_rtems_initialise+0xec><== NOT EXECUTED
40013b20: b2 82 20 01 addcc %o0, 1, %i1 <== NOT EXECUTED
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40013b24: 7f ff d2 a6 call 400085bc <malloc>
40013b28: 90 10 20 04 mov 4, %o0
if (!rtems)
40013b2c: b8 92 20 00 orcc %o0, 0, %i4
40013b30: 02 80 00 75 be 40013d04 <rtems_rfs_rtems_initialise+0x268><== NEVER TAKEN
40013b34: 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);
40013b38: 40 00 32 a5 call 400205cc <rtems_rfs_mutex_create>
40013b3c: c0 27 00 00 clr [ %i4 ]
if (rc > 0)
40013b40: b6 92 20 00 orcc %o0, 0, %i3
40013b44: 24 80 00 1f ble,a 40013bc0 <rtems_rfs_rtems_initialise+0x124><== ALWAYS TAKEN
40013b48: d0 07 00 00 ld [ %i4 ], %o0
{
free (rtems);
40013b4c: 7f ff d0 ff call 40007f48 <free> <== NOT EXECUTED
40013b50: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
40013b54: 40 00 3b 79 call 40022938 <__errno> <== NOT EXECUTED
40013b58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013b5c: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
40013b60: 81 c7 e0 08 ret <== NOT EXECUTED
40013b64: 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",
40013b68: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40013b6c: 40 00 45 a7 call 40025208 <strncmp> <== NOT EXECUTED
40013b70: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
40013b74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013b78: 12 80 00 07 bne 40013b94 <rtems_rfs_rtems_initialise+0xf8><== NOT EXECUTED
40013b7c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
40013b80: 10 bf ff df b 40013afc <rtems_rfs_rtems_initialise+0x60> <== NOT EXECUTED
40013b84: ba 17 60 02 or %i5, 2, %i5 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
40013b88: 12 bf ff d3 bne 40013ad4 <rtems_rfs_rtems_initialise+0x38><== NOT EXECUTED
40013b8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40013b90: 30 bf ff e5 b,a 40013b24 <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",
40013b94: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40013b98: 40 00 45 9c call 40025208 <strncmp> <== NOT EXECUTED
40013b9c: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
40013ba0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013ba4: 12 80 00 2c bne 40013c54 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
40013ba8: 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);
40013bac: 92 10 20 00 clr %o1 <== NOT EXECUTED
40013bb0: 40 00 46 75 call 40025584 <strtoul> <== NOT EXECUTED
40013bb4: 94 10 20 00 clr %o2 <== NOT EXECUTED
40013bb8: 10 bf ff d1 b 40013afc <rtems_rfs_rtems_initialise+0x60> <== NOT EXECUTED
40013bbc: 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);
40013bc0: 92 10 20 00 clr %o1
40013bc4: 7f ff e4 49 call 4000cce8 <rtems_semaphore_obtain>
40013bc8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40013bcc: b6 92 20 00 orcc %o0, 0, %i3
40013bd0: 12 80 00 11 bne 40013c14 <rtems_rfs_rtems_initialise+0x178><== NEVER TAKEN
40013bd4: 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);
40013bd8: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
40013bdc: 92 10 00 1c mov %i4, %o1
40013be0: 96 10 00 11 mov %l1, %o3
40013be4: 40 00 2d a1 call 4001f268 <rtems_rfs_fs_open>
40013be8: 98 07 bf fc add %fp, -4, %o4
if (rc)
40013bec: ba 92 20 00 orcc %o0, 0, %i5
40013bf0: 02 80 00 1f be 40013c6c <rtems_rfs_rtems_initialise+0x1d0><== ALWAYS TAKEN
40013bf4: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
40013bf8: 7f ff d0 d4 call 40007f48 <free> <== NOT EXECUTED
40013bfc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
40013c00: 40 00 3b 4e call 40022938 <__errno> <== NOT EXECUTED
40013c04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013c08: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
40013c0c: 81 c7 e0 08 ret <== NOT EXECUTED
40013c10: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40013c14: 90 10 20 00 clr %o0 <== NOT EXECUTED
40013c18: 40 00 00 a3 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40013c1c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40013c20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013c24: 12 80 00 25 bne 40013cb8 <rtems_rfs_rtems_initialise+0x21c><== NOT EXECUTED
40013c28: 01 00 00 00 nop <== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
40013c2c: 40 00 32 83 call 40020638 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
40013c30: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free (rtems);
40013c34: 7f ff d0 c5 call 40007f48 <free> <== NOT EXECUTED
40013c38: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
40013c3c: 40 00 3b 3f call 40022938 <__errno> <== NOT EXECUTED
40013c40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013c44: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40013c48: 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;
}
40013c4c: 81 c7 e0 08 ret <== NOT EXECUTED
40013c50: 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);
40013c54: 40 00 3b 39 call 40022938 <__errno> <== NOT EXECUTED
40013c58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013c5c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40013c60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013c64: 81 c7 e0 08 ret <== NOT EXECUTED
40013c68: 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;
40013c6c: 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;
40013c70: 05 10 00 d7 sethi %hi(0x40035c00), %g2
40013c74: 84 10 a3 80 or %g2, 0x380, %g2 ! 40035f80 <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);
40013c78: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
40013c7c: d0 26 20 08 st %o0, [ %i0 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
40013c80: c4 26 20 0c st %g2, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40013c84: 84 10 20 01 mov 1, %g2
40013c88: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
40013c8c: 05 10 00 e0 sethi %hi(0x40038000), %g2
40013c90: 84 10 a2 c8 or %g2, 0x2c8, %g2 ! 400382c8 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
40013c94: 40 00 23 ad call 4001cb48 <rtems_rfs_buffers_release>
40013c98: 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);
40013c9c: 7f ff e4 62 call 4000ce24 <rtems_semaphore_release>
40013ca0: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40013ca4: ba 92 20 00 orcc %o0, 0, %i5
40013ca8: 12 80 00 0b bne 40013cd4 <rtems_rfs_rtems_initialise+0x238><== NEVER TAKEN
40013cac: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
40013cb0: 81 c7 e0 08 ret
40013cb4: 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",
40013cb8: 40 00 0e d6 call 40017810 <rtems_status_text> <== NOT EXECUTED
40013cbc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40013cc0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40013cc4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40013cc8: 40 00 40 ad call 40023f7c <printf> <== NOT EXECUTED
40013ccc: 90 12 23 58 or %o0, 0x358, %o0 ! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40013cd0: 30 bf ff d7 b,a 40013c2c <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))
40013cd4: 40 00 00 74 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40013cd8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40013cdc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013ce0: 02 bf ff f4 be 40013cb0 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
40013ce4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40013ce8: 40 00 0e ca call 40017810 <rtems_status_text> <== NOT EXECUTED
40013cec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40013cf0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40013cf4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40013cf8: 40 00 40 a1 call 40023f7c <printf> <== NOT EXECUTED
40013cfc: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40013d00: 30 bf ff ec b,a 40013cb0 <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);
40013d04: 40 00 3b 0d call 40022938 <__errno> <== NOT EXECUTED
40013d08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013d0c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40013d10: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013d14: 81 c7 e0 08 ret <== NOT EXECUTED
40013d18: 81 e8 00 00 restore <== NOT EXECUTED
40012e48 <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)
{
40012e48: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
40012e4c: 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);
40012e50: d6 06 20 08 ld [ %i0 + 8 ], %o3
40012e54: d0 00 60 08 ld [ %g1 + 8 ], %o0
40012e58: d8 06 60 08 ld [ %i1 + 8 ], %o4
40012e5c: 92 10 00 1a mov %i2, %o1
40012e60: 94 10 00 1b mov %i3, %o2
40012e64: 9a 10 20 00 clr %o5
40012e68: 40 00 33 4c call 4001fb98 <rtems_rfs_link>
40012e6c: b0 10 20 00 clr %i0
if (rc)
40012e70: 80 a2 20 00 cmp %o0, 0
40012e74: 02 80 00 05 be 40012e88 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
40012e78: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
40012e7c: 40 00 3e af call 40022938 <__errno> <== NOT EXECUTED
40012e80: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012e84: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012e88: 81 c7 e0 08 ret
40012e8c: 81 e8 00 00 restore
40013d1c <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
)
{
40013d1c: 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);
40013d20: 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);
40013d24: 92 10 20 00 clr %o1
/* FIXME: Return value? */
rtems_rfs_fs_close(fs);
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
}
40013d28: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
40013d2c: 94 10 20 00 clr %o2
40013d30: 7f ff e3 ee call 4000cce8 <rtems_semaphore_obtain>
40013d34: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40013d38: ba 92 20 00 orcc %o0, 0, %i5
40013d3c: 12 80 00 04 bne 40013d4c <rtems_rfs_rtems_lock_by_mt_entry+0x30><== NEVER TAKEN
40013d40: 90 10 20 00 clr %o0
40013d44: 81 c7 e0 08 ret
40013d48: 81 e8 00 00 restore
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40013d4c: 40 00 00 56 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40013d50: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40013d54: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013d58: 02 bf ff fb be 40013d44 <rtems_rfs_rtems_lock_by_mt_entry+0x28><== NOT EXECUTED
40013d5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40013d60: 40 00 0e ac call 40017810 <rtems_status_text> <== NOT EXECUTED
40013d64: 31 10 00 d7 sethi %hi(0x40035c00), %i0 <== NOT EXECUTED
40013d68: b0 16 23 58 or %i0, 0x358, %i0 ! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40013d6c: 40 00 40 84 call 40023f7c <printf> <== NOT EXECUTED
40013d70: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
4001331c <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)
{
4001331c: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
40013320: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
40013324: e0 06 20 08 ld [ %i0 + 8 ], %l0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
40013328: 40 00 12 0f call 40017b64 <geteuid>
4001332c: f0 00 60 08 ld [ %g1 + 8 ], %i0
gid = getegid ();
40013330: 40 00 12 09 call 40017b54 <getegid>
40013334: a2 10 00 08 mov %o0, %l1
40013338: a4 10 00 08 mov %o0, %l2
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
4001333c: 40 00 02 d5 call 40013e90 <rtems_rfs_rtems_imode>
40013340: 90 10 00 1b mov %i3, %o0
40013344: 82 07 bf d4 add %fp, -44, %g1
40013348: 99 2a 20 10 sll %o0, 0x10, %o4
4001334c: 96 10 00 1a mov %i2, %o3
40013350: a3 2c 60 10 sll %l1, 0x10, %l1
40013354: a5 2c a0 10 sll %l2, 0x10, %l2
40013358: a3 34 60 10 srl %l1, 0x10, %l1
4001335c: a5 34 a0 10 srl %l2, 0x10, %l2
40013360: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
40013364: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
40013368: 90 10 00 18 mov %i0, %o0
4001336c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40013370: 92 10 00 10 mov %l0, %o1
40013374: 94 10 00 19 mov %i1, %o2
40013378: 99 33 20 10 srl %o4, 0x10, %o4
4001337c: 7f ff fd 75 call 40012950 <rtems_rfs_inode_create>
40013380: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
40013384: b4 92 20 00 orcc %o0, 0, %i2
40013388: 04 80 00 07 ble 400133a4 <rtems_rfs_rtems_mknod+0x88>
4001338c: 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);
40013390: 40 00 3d 6a call 40022938 <__errno>
40013394: b0 10 3f ff mov -1, %i0
40013398: f4 22 00 00 st %i2, [ %o0 ]
4001339c: 81 c7 e0 08 ret
400133a0: 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);
400133a4: 90 10 00 18 mov %i0, %o0
400133a8: 94 07 bf d8 add %fp, -40, %o2
400133ac: 7f ff fc 17 call 40012408 <rtems_rfs_inode_open>
400133b0: 96 10 20 01 mov 1, %o3
if (rc > 0)
400133b4: b4 92 20 00 orcc %o0, 0, %i2
400133b8: 14 bf ff f6 bg 40013390 <rtems_rfs_rtems_mknod+0x74> <== NEVER TAKEN
400133bc: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
}
if (S_ISDIR(mode) || S_ISREG(mode))
400133c0: 05 00 00 20 sethi %hi(0x8000), %g2
400133c4: 82 0e c0 01 and %i3, %g1, %g1
400133c8: 80 a0 40 02 cmp %g1, %g2
400133cc: 02 80 00 1a be 40013434 <rtems_rfs_rtems_mknod+0x118>
400133d0: 05 00 00 10 sethi %hi(0x4000), %g2
400133d4: 80 a0 40 02 cmp %g1, %g2
400133d8: 02 80 00 17 be 40013434 <rtems_rfs_rtems_mknod+0x118> <== ALWAYS TAKEN
400133dc: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
400133e0: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
400133e4: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
400133e8: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
400133ec: 12 80 00 1e bne 40013464 <rtems_rfs_rtems_mknod+0x148> <== NOT EXECUTED
400133f0: 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);
400133f4: b3 37 20 18 srl %i4, 0x18, %i1 <== NOT EXECUTED
400133f8: b5 37 20 10 srl %i4, 0x10, %i2 <== NOT EXECUTED
400133fc: b7 37 20 08 srl %i4, 8, %i3 <== NOT EXECUTED
40013400: 89 37 60 18 srl %i5, 0x18, %g4 <== NOT EXECUTED
40013404: 87 37 60 10 srl %i5, 0x10, %g3 <== NOT EXECUTED
40013408: 85 37 60 08 srl %i5, 8, %g2 <== NOT EXECUTED
4001340c: f8 28 60 1f stb %i4, [ %g1 + 0x1f ] <== NOT EXECUTED
40013410: f2 28 60 1c stb %i1, [ %g1 + 0x1c ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013414: 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);
40013418: f4 28 60 1d stb %i2, [ %g1 + 0x1d ] <== NOT EXECUTED
4001341c: f6 28 60 1e stb %i3, [ %g1 + 0x1e ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013420: 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);
40013424: c8 28 60 20 stb %g4, [ %g1 + 0x20 ] <== NOT EXECUTED
40013428: c6 28 60 21 stb %g3, [ %g1 + 0x21 ] <== NOT EXECUTED
4001342c: c4 28 60 22 stb %g2, [ %g1 + 0x22 ] <== NOT EXECUTED
40013430: 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);
40013434: 90 10 00 18 mov %i0, %o0
40013438: 92 07 bf d8 add %fp, -40, %o1
4001343c: 7f ff fc 6b call 400125e8 <rtems_rfs_inode_close>
40013440: b0 10 20 00 clr %i0
if (rc > 0)
40013444: 80 a2 20 00 cmp %o0, 0
40013448: 04 bf ff d5 ble 4001339c <rtems_rfs_rtems_mknod+0x80> <== ALWAYS TAKEN
4001344c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
40013450: 40 00 3d 3a call 40022938 <__errno> <== NOT EXECUTED
40013454: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013458: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
4001345c: 81 c7 e0 08 ret <== NOT EXECUTED
40013460: 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);
40013464: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013468: 7f ff fc 60 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001346c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
40013470: 40 00 3d 32 call 40022938 <__errno> <== NOT EXECUTED
40013474: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013478: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001347c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013480: 81 c7 e0 08 ret <== NOT EXECUTED
40013484: 81 e8 00 00 restore <== NOT EXECUTED
400132b0 <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)
{
400132b0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400132b4: 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);
400132b8: 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);
400132bc: 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);
400132c0: 94 07 bf d8 add %fp, -40, %o2
400132c4: 90 10 00 1c mov %i4, %o0
400132c8: 7f ff fc 50 call 40012408 <rtems_rfs_inode_open>
400132cc: 96 10 20 01 mov 1, %o3
if (rc > 0)
400132d0: ba 92 20 00 orcc %o0, 0, %i5
400132d4: 04 80 00 07 ble 400132f0 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
400132d8: 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);
400132dc: 40 00 3d 97 call 40022938 <__errno> <== NOT EXECUTED
400132e0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400132e4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
400132e8: 81 c7 e0 08 ret <== NOT EXECUTED
400132ec: 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);
400132f0: 7f ff fe 90 call 40012d30 <rtems_rfs_rtems_node_type_by_inode>
400132f4: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
400132f8: 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);
400132fc: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
40013300: 7f ff fc ba call 400125e8 <rtems_rfs_inode_close>
40013304: 90 10 00 1c mov %i4, %o0
if (rc > 0)
40013308: ba 92 20 00 orcc %o0, 0, %i5
4001330c: 14 bf ff f4 bg 400132dc <rtems_rfs_rtems_node_type+0x2c> <== NEVER TAKEN
40013310: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
}
return type;
}
40013314: 81 c7 e0 08 ret
40013318: 81 e8 00 00 restore
40012f60 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
40012f60: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012f64: 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);
40012f68: d2 06 20 08 ld [ %i0 + 8 ], %o1
40012f6c: d0 00 60 08 ld [ %g1 + 8 ], %o0
40012f70: 94 10 00 19 mov %i1, %o2
40012f74: 96 10 00 1a mov %i2, %o3
40012f78: 40 00 35 23 call 40020404 <rtems_rfs_symlink_read>
40012f7c: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
40012f80: 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)
40012f84: 80 a2 20 00 cmp %o0, 0
40012f88: 02 80 00 05 be 40012f9c <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
40012f8c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
40012f90: 40 00 3e 6a call 40022938 <__errno> <== NOT EXECUTED
40012f94: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012f98: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
40012f9c: 81 c7 e0 08 ret
40012fa0: 81 e8 00 00 restore
40012e90 <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)
{
40012e90: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
40012e94: 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);
40012e98: 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);
40012e9c: 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);
40012ea0: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
40012ea4: 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);
40012ea8: 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);
40012eac: 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);
40012eb0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40012eb4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40012eb8: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
40012ebc: 40 00 33 37 call 4001fb98 <rtems_rfs_link> <== NOT EXECUTED
40012ec0: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
40012ec4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40012ec8: 02 80 00 07 be 40012ee4 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
40012ecc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
40012ed0: 40 00 3e 9a call 40022938 <__errno> <== NOT EXECUTED
40012ed4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012ed8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40012edc: 81 c7 e0 08 ret <== NOT EXECUTED
40012ee0: 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,
40012ee4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40012ee8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40012eec: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40012ef0: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
40012ef4: 40 00 33 9d call 4001fd68 <rtems_rfs_unlink> <== NOT EXECUTED
40012ef8: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
40012efc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40012f00: 02 bf ff f7 be 40012edc <rtems_rfs_rtems_rename+0x4c> <== NOT EXECUTED
40012f04: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
40012f08: 40 00 3e 8c call 40022938 <__errno> <== NOT EXECUTED
40012f0c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012f10: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40012f14: 81 c7 e0 08 ret <== NOT EXECUTED
40012f18: 81 e8 00 00 restore <== NOT EXECUTED
40013da8 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
40013da8: 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);
40013dac: 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))
40013db0: 07 00 00 10 sethi %hi(0x4000), %g3
40013db4: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
40013db8: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
40013dbc: 83 28 60 08 sll %g1, 8, %g1
40013dc0: 82 10 40 02 or %g1, %g2, %g1
40013dc4: 05 00 00 3c sethi %hi(0xf000), %g2
40013dc8: 84 08 40 02 and %g1, %g2, %g2
40013dcc: 80 a0 80 03 cmp %g2, %g3
40013dd0: 02 80 00 1d be 40013e44 <rtems_rfs_rtems_set_handlers+0x9c>
40013dd4: 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))
40013dd8: 09 00 00 2c sethi %hi(0xb000), %g4
40013ddc: 07 00 00 08 sethi %hi(0x2000), %g3
40013de0: 88 08 40 04 and %g1, %g4, %g4
40013de4: 80 a1 00 03 cmp %g4, %g3
40013de8: 02 80 00 10 be 40013e28 <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
40013dec: 07 00 00 28 sethi %hi(0xa000), %g3
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
40013df0: 80 a0 80 03 cmp %g2, %g3
40013df4: 02 80 00 22 be 40013e7c <rtems_rfs_rtems_set_handlers+0xd4>
40013df8: 07 00 00 20 sethi %hi(0x8000), %g3
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
40013dfc: 80 a0 80 03 cmp %g2, %g3
40013e00: 02 80 00 18 be 40013e60 <rtems_rfs_rtems_set_handlers+0xb8><== ALWAYS TAKEN
40013e04: 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);
40013e08: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
40013e0c: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
40013e10: 40 00 40 5b call 40023f7c <printf> <== NOT EXECUTED
40013e14: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
return false;
40013e18: 82 10 20 00 clr %g1 <== NOT EXECUTED
}
return true;
}
40013e1c: b0 08 60 01 and %g1, 1, %i0
40013e20: 81 c7 e0 08 ret
40013e24: 81 e8 00 00 restore
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40013e28: 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);
40013e2c: 05 10 00 e0 sethi %hi(0x40038000), %g2 <== NOT EXECUTED
40013e30: 84 10 a2 9c or %g2, 0x29c, %g2 ! 4003829c <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
40013e34: c4 26 20 10 st %g2, [ %i0 + 0x10 ] <== NOT EXECUTED
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
40013e38: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
40013e3c: 81 c7 e0 08 ret <== NOT EXECUTED
40013e40: 81 e8 00 00 restore <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40013e44: 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);
40013e48: 05 10 00 e0 sethi %hi(0x40038000), %g2
40013e4c: 84 10 a2 c8 or %g2, 0x2c8, %g2 ! 400382c8 <rtems_rfs_rtems_dir_handlers>
40013e50: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
40013e54: b0 08 60 01 and %g1, 1, %i0
40013e58: 81 c7 e0 08 ret
40013e5c: 81 e8 00 00 restore
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40013e60: 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);
40013e64: 05 10 00 e0 sethi %hi(0x40038000), %g2
40013e68: 84 10 a2 f4 or %g2, 0x2f4, %g2 ! 400382f4 <rtems_rfs_rtems_file_handlers>
40013e6c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
40013e70: b0 08 60 01 and %g1, 1, %i0
40013e74: 81 c7 e0 08 ret
40013e78: 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);
40013e7c: 05 10 00 d7 sethi %hi(0x40035c00), %g2
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40013e80: 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);
40013e84: 84 10 a3 d4 or %g2, 0x3d4, %g2
40013e88: 10 bf ff e5 b 40013e1c <rtems_rfs_rtems_set_handlers+0x74>
40013e8c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
40012db4 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
40012db4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40012db8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40012dbc: 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);
40012dc0: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40012dc4: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
40012dc8: 7f ff fd 2e call 40012280 <rtems_rfs_group_usage> <== NOT EXECUTED
40012dcc: 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);
40012dd0: 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;
40012dd4: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
40012dd8: 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);
40012ddc: f0 07 60 08 ld [ %i5 + 8 ], %i0 <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40012de0: f4 00 60 20 ld [ %g1 + 0x20 ], %i2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40012de4: 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);
40012de8: 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);
40012dec: 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);
40012df0: 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;
40012df4: 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;
40012df8: 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);
40012dfc: 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;
40012e00: 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);
40012e04: 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);
40012e08: f4 26 60 04 st %i2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40012e0c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
40012e10: f6 26 60 0c st %i3, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40012e14: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
40012e18: c6 26 60 14 st %g3, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
40012e1c: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
40012e20: 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;
40012e24: c4 26 60 24 st %g2, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
40012e28: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
40012e2c: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
40012e30: 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;
40012e34: 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);
40012e38: 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;
40012e3c: 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;
}
40012e40: 81 c7 e0 08 ret <== NOT EXECUTED
40012e44: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40012fa4 <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)
{
40012fa4: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
40012fa8: 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),
40012fac: 90 10 00 1b mov %i3, %o0
40012fb0: 40 00 48 64 call 40025140 <strlen>
40012fb4: 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);
40012fb8: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
40012fbc: 40 00 12 ea call 40017b64 <geteuid>
40012fc0: ba 10 00 08 mov %o0, %i5
40012fc4: 40 00 12 e4 call 40017b54 <getegid>
40012fc8: a0 10 00 08 mov %o0, %l0
40012fcc: 91 2a 20 10 sll %o0, 0x10, %o0
40012fd0: 91 32 20 10 srl %o0, 0x10, %o0
40012fd4: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
40012fd8: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
40012fdc: 98 10 00 1d mov %i5, %o4
40012fe0: 9b 2c 20 10 sll %l0, 0x10, %o5
40012fe4: 90 10 00 1c mov %i4, %o0
40012fe8: 92 10 00 19 mov %i1, %o1
40012fec: 94 10 00 1a mov %i2, %o2
40012ff0: 96 10 00 1b mov %i3, %o3
40012ff4: 9b 33 60 10 srl %o5, 0x10, %o5
40012ff8: 40 00 34 68 call 40020198 <rtems_rfs_symlink>
40012ffc: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
40013000: 80 a2 20 00 cmp %o0, 0
40013004: 02 80 00 05 be 40013018 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
40013008: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
4001300c: 40 00 3e 4b call 40022938 <__errno> <== NOT EXECUTED
40013010: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013014: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40013018: 81 c7 e0 08 ret
4001301c: 81 e8 00 00 restore
40013a48 <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
)
{
40013a48: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = mt_entry->fs_info;
40013a4c: 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);
40013a50: 40 00 24 3e call 4001cb48 <rtems_rfs_buffers_release>
40013a54: 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);
40013a58: 7f ff e4 f3 call 4000ce24 <rtems_semaphore_release>
40013a5c: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40013a60: ba 92 20 00 orcc %o0, 0, %i5
40013a64: 12 80 00 04 bne 40013a74 <rtems_rfs_rtems_unlock_by_mt_entry+0x2c><== NEVER TAKEN
40013a68: 90 10 20 00 clr %o0
40013a6c: 81 c7 e0 08 ret
40013a70: 81 e8 00 00 restore
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40013a74: 40 00 01 0c call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
40013a78: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40013a7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013a80: 02 bf ff fb be 40013a6c <rtems_rfs_rtems_unlock_by_mt_entry+0x24><== NOT EXECUTED
40013a84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40013a88: 40 00 0f 62 call 40017810 <rtems_status_text> <== NOT EXECUTED
40013a8c: 31 10 00 d7 sethi %hi(0x40035c00), %i0 <== NOT EXECUTED
40013a90: b0 16 22 f0 or %i0, 0x2f0, %i0 ! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40013a94: 40 00 41 3a call 40023f7c <printf> <== NOT EXECUTED
40013a98: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
40013020 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
40013020: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40013024: 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);
40013028: 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);
4001302c: 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);
40013030: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40013034: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40013038: 7f ff fc f4 call 40012408 <rtems_rfs_inode_open> <== NOT EXECUTED
4001303c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40013040: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40013044: 02 80 00 07 be 40013060 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
40013048: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
4001304c: 40 00 3e 3b call 40022938 <__errno> <== NOT EXECUTED
40013050: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013054: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40013058: 81 c7 e0 08 ret <== NOT EXECUTED
4001305c: 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);
40013060: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
40013064: 87 36 60 10 srl %i1, 0x10, %g3 <== NOT EXECUTED
40013068: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
4001306c: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
40013070: c6 28 60 11 stb %g3, [ %g1 + 0x11 ] <== NOT EXECUTED
40013074: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013078: 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);
4001307c: 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);
40013080: 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);
40013084: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
40013088: 87 36 a0 10 srl %i2, 0x10, %g3 <== NOT EXECUTED
4001308c: 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);
40013090: 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);
40013094: 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);
40013098: c6 28 60 15 stb %g3, [ %g1 + 0x15 ] <== NOT EXECUTED
4001309c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
400130a0: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
400130a4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
400130a8: 7f ff fd 50 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
400130ac: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
400130b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400130b4: 02 bf ff e9 be 40013058 <rtems_rfs_rtems_utime+0x38> <== NOT EXECUTED
400130b8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
400130bc: 40 00 3e 1f call 40022938 <__errno> <== NOT EXECUTED
400130c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400130c4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
400130c8: 81 c7 e0 08 ret <== NOT EXECUTED
400130cc: 81 e8 00 00 restore <== NOT EXECUTED
40010c4c <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)
{
40010c4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
40010c50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (dividend == 0)
40010c54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40010c58: 02 80 00 06 be 40010c70 <rtems_rfs_rup_quotient+0x24> <== NOT EXECUTED
40010c5c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
40010c60: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
40010c64: 7f ff c6 8f call 400026a0 <.udiv> <== NOT EXECUTED
40010c68: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40010c6c: b0 02 20 01 add %o0, 1, %i0 <== NOT EXECUTED
}
40010c70: 81 c7 e0 08 ret <== NOT EXECUTED
40010c74: 81 e8 00 00 restore <== NOT EXECUTED
4001c318 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
4001c318: 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))
4001c31c: 90 10 20 00 clr %o0
4001c320: 92 10 20 80 mov 0x80, %o1
4001c324: 7f ff de e0 call 40013ea4 <rtems_rfs_trace>
4001c328: fa 06 20 08 ld [ %i0 + 8 ], %i5
4001c32c: 80 8a 20 ff btst 0xff, %o0
4001c330: 32 80 00 37 bne,a 4001c40c <rtems_rfs_scan_chain+0xf4> <== NEVER TAKEN
4001c334: 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));
4001c338: 39 10 00 db sethi %hi(0x40036c00), %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))
4001c33c: 80 a7 40 18 cmp %i5, %i0
4001c340: 12 80 00 0b bne 4001c36c <rtems_rfs_scan_chain+0x54> <== ALWAYS TAKEN
4001c344: b8 17 21 58 or %i4, 0x158, %i4
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001c348: 10 80 00 2a b 4001c3f0 <rtems_rfs_scan_chain+0xd8> <== NOT EXECUTED
4001c34c: 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)
4001c350: 80 a0 40 1a cmp %g1, %i2
4001c354: 02 80 00 14 be 4001c3a4 <rtems_rfs_scan_chain+0x8c>
4001c358: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
4001c35c: 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))
4001c360: 80 a7 40 18 cmp %i5, %i0
4001c364: 02 80 00 23 be 4001c3f0 <rtems_rfs_scan_chain+0xd8>
4001c368: 90 10 20 00 clr %o0
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001c36c: 90 10 20 00 clr %o0
4001c370: 7f ff de cd call 40013ea4 <rtems_rfs_trace>
4001c374: 92 10 20 80 mov 0x80, %o1
4001c378: 80 8a 20 ff btst 0xff, %o0
4001c37c: 22 bf ff f5 be,a 4001c350 <rtems_rfs_scan_chain+0x38> <== ALWAYS TAKEN
4001c380: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001c384: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001c388: 40 00 1e fd call 40023f7c <printf> <== NOT EXECUTED
4001c38c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001c390: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
4001c394: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
4001c398: 32 bf ff f2 bne,a 4001c360 <rtems_rfs_scan_chain+0x48> <== NOT EXECUTED
4001c39c: fa 07 60 04 ld [ %i5 + 4 ], %i5 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001c3a0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c3a4: 7f ff de c0 call 40013ea4 <rtems_rfs_trace>
4001c3a8: 92 10 20 80 mov 0x80, %o1
4001c3ac: 80 8a 20 ff btst 0xff, %o0
4001c3b0: 22 80 00 07 be,a 4001c3cc <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
4001c3b4: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
4001c3b8: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001c3bc: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c3c0: 40 00 1e ef call 40023f7c <printf> <== NOT EXECUTED
4001c3c4: 90 12 21 60 or %o0, 0x160, %o0 ! 40036d60 <CSWTCH.2+0x170><== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
4001c3c8: 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 );
4001c3cc: 90 10 00 1d mov %i5, %o0
4001c3d0: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
4001c3d4: b0 10 00 1d mov %i5, %i0
4001c3d8: 7f ff f3 a1 call 4001925c <_Chain_Extract>
4001c3dc: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4001c3e0: c0 27 60 04 clr [ %i5 + 4 ]
4001c3e4: c0 27 40 00 clr [ %i5 ]
4001c3e8: 81 c7 e0 08 ret
4001c3ec: 81 e8 00 00 restore
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001c3f0: 7f ff de ad call 40013ea4 <rtems_rfs_trace>
4001c3f4: 92 10 20 80 mov 0x80, %o1
4001c3f8: 80 8a 20 ff btst 0xff, %o0
4001c3fc: 12 80 00 0a bne 4001c424 <rtems_rfs_scan_chain+0x10c> <== NEVER TAKEN
4001c400: 11 10 00 db sethi %hi(0x40036c00), %o0
printf (": not found\n");
return NULL;
}
4001c404: 81 c7 e0 08 ret
4001c408: 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);
4001c40c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001c410: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001c414: 40 00 1e da call 40023f7c <printf> <== NOT EXECUTED
4001c418: 90 12 21 28 or %o0, 0x128, %o0 ! 40036d28 <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));
4001c41c: 10 bf ff c8 b 4001c33c <rtems_rfs_scan_chain+0x24> <== NOT EXECUTED
4001c420: 39 10 00 db sethi %hi(0x40036c00), %i4 <== NOT EXECUTED
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": not found\n");
return NULL;
4001c424: 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");
4001c428: 40 00 1f 6d call 400241dc <puts> <== NOT EXECUTED
4001c42c: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED
return NULL;
}
4001c430: 81 c7 e0 08 ret <== NOT EXECUTED
4001c434: 81 e8 00 00 restore <== NOT EXECUTED
4001aa08 <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,
4001aa08: 9d e3 bf 90 save %sp, -112, %sp
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
4001aa0c: 90 10 00 18 mov %i0, %o0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aa10: ac 10 00 18 mov %i0, %l6
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
4001aa14: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
4001aa18: 7f ff ff e7 call 4001a9b4 <rtems_rfs_bitmap_load_map>
4001aa1c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001aa20: b0 92 20 00 orcc %o0, 0, %i0
4001aa24: 24 80 00 04 ble,a 4001aa34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2c><== ALWAYS TAKEN
4001aa28: f8 06 40 00 ld [ %i1 ], %i4
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
4001aa2c: 81 c7 e0 08 ret <== NOT EXECUTED
4001aa30: 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);
4001aa34: a1 2e e0 0b sll %i3, 0xb, %l0
if (end_bit < 0)
4001aa38: a0 84 00 1c addcc %l0, %i4, %l0
4001aa3c: 2c 80 00 06 bneg,a 4001aa54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001aa40: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
4001aa44: c2 05 a0 0c ld [ %l6 + 0xc ], %g1
4001aa48: 80 a4 00 01 cmp %l0, %g1
4001aa4c: 3a 80 00 02 bcc,a 4001aa54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001aa50: 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];
4001aa54: ee 05 a0 14 ld [ %l6 + 0x14 ], %l7
map_bits = &map[map_index];
4001aa58: 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);
4001aa5c: 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];
4001aa60: 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);
4001aa64: 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))
4001aa68: 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];
4001aa6c: 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)))
4001aa70: 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];
4001aa74: 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)))
4001aa78: 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))
4001aa7c: 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);
4001aa80: 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);
4001aa84: 92 0c a0 1f and %l2, 0x1f, %o1
search_bits = &control->search_bits[search_index];
4001aa88: ae 05 c0 02 add %l7, %g2, %l7
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
4001aa8c: b1 2e e0 02 sll %i3, 2, %i0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aa90: 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);
4001aa94: 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))
4001aa98: c2 27 bf f4 st %g1, [ %fp + -12 ]
|| ((direction > 0) && (test_bit >= end_bit)))
4001aa9c: 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))
4001aaa0: c8 05 c0 00 ld [ %l7 ], %g4
4001aaa4: 80 a1 20 00 cmp %g4, 0
4001aaa8: 02 80 00 49 be 4001abcc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1c4>
4001aaac: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aab0: 86 06 c0 12 add %i3, %l2, %g3
4001aab4: 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)
4001aab8: 80 a2 60 1f cmp %o1, 0x1f
4001aabc: 18 80 00 52 bgu 4001ac04 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1fc>
4001aac0: 9f 2c 40 09 sll %l1, %o1, %o7
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
4001aac4: 80 8b c0 04 btst %o7, %g4
4001aac8: 22 80 00 13 be,a 4001ab14 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10c>
4001aacc: 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))
4001aad0: 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);
4001aad4: 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))
4001aad8: 80 88 40 02 btst %g1, %g2
4001aadc: 02 80 00 0b be 4001ab08 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x100>
4001aae0: 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);
4001aae4: 10 80 00 55 b 4001ac38 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x230>
4001aae8: 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)
4001aaec: 80 a7 60 1f cmp %i5, 0x1f
4001aaf0: 18 80 00 08 bgu 4001ab10 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108><== NEVER TAKEN
4001aaf4: 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);
4001aaf8: 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))
4001aafc: 80 88 80 01 btst %g2, %g1
4001ab00: 12 80 00 4d bne 4001ac34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x22c>
4001ab04: 80 a4 00 1c cmp %l0, %i4
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
4001ab08: 32 bf ff f9 bne,a 4001aaec <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe4>
4001ab0c: ba 07 40 1b add %i5, %i3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
4001ab10: a6 04 c0 18 add %l3, %i0, %l3
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ab14: 80 a6 e0 00 cmp %i3, 0
4001ab18: 04 80 00 44 ble 4001ac28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x220>
4001ab1c: a4 04 80 1b add %l2, %i3, %l2
4001ab20: b8 10 20 00 clr %i4
4001ab24: ba 10 20 00 clr %i5
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
4001ab28: b8 00 c0 1c add %g3, %i4, %i4
search_offset += direction;
4001ab2c: 92 02 40 1b add %o1, %i3, %o1
if (((direction < 0) && (test_bit <= end_bit))
4001ab30: 84 10 00 15 mov %l5, %g2
4001ab34: 80 a4 00 1c cmp %l0, %i4
4001ab38: 16 80 00 03 bge 4001ab44 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x13c>
4001ab3c: 82 10 20 01 mov 1, %g1
4001ab40: 82 10 20 00 clr %g1
4001ab44: 80 88 60 ff btst 0xff, %g1
4001ab48: 32 80 00 5b bne,a 4001acb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2ac>
4001ab4c: c2 07 bf f4 ld [ %fp + -12 ], %g1
4001ab50: 86 00 c0 0b add %g3, %o3, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
4001ab54: 80 a4 00 1c cmp %l0, %i4
4001ab58: 04 80 00 03 ble 4001ab64 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c>
4001ab5c: 82 10 20 01 mov 1, %g1
4001ab60: 82 10 20 00 clr %g1
4001ab64: 80 88 60 ff btst 0xff, %g1
4001ab68: 02 bf ff d5 be 4001aabc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001ab6c: 80 a2 60 1f cmp %o1, 0x1f
4001ab70: 80 a5 20 00 cmp %l4, 0
4001ab74: 02 bf ff d2 be 4001aabc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001ab78: 80 a2 60 1f cmp %o1, 0x1f
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
4001ab7c: 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)))
4001ab80: 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;
4001ab84: 92 10 20 00 clr %o1
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
4001ab88: 80 88 60 ff btst 0xff, %g1
4001ab8c: 02 80 00 06 be 4001aba4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x19c>
4001ab90: 80 a4 00 1c cmp %l0, %i4
4001ab94: 80 88 a0 ff btst 0xff, %g2
4001ab98: 32 bf ff c3 bne,a 4001aaa4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001ab9c: c8 05 c0 00 ld [ %l7 ], %g4
4001aba0: 80 a4 00 1c cmp %l0, %i4
4001aba4: 16 80 00 03 bge 4001abb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a8>
4001aba8: 82 10 20 01 mov 1, %g1
4001abac: 82 10 20 00 clr %g1
4001abb0: 80 88 60 ff btst 0xff, %g1
4001abb4: 02 80 00 04 be 4001abc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1bc>
4001abb8: 80 a5 20 00 cmp %l4, 0
4001abbc: 32 bf ff ba bne,a 4001aaa4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001abc0: c8 05 c0 00 ld [ %l7 ], %g4
return 0;
4001abc4: 81 c7 e0 08 ret
4001abc8: 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)
4001abcc: 04 80 00 34 ble 4001ac9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x294>
4001abd0: b8 0f 3f e0 and %i4, -32, %i4
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001abd4: 82 10 20 20 mov 0x20, %g1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
4001abd8: 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;
4001abdc: 92 20 40 09 sub %g1, %o1, %o1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
4001abe0: 83 2a 60 05 sll %o1, 5, %g1
4001abe4: 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;
4001abe8: d6 27 bf f0 st %o3, [ %fp + -16 ]
4001abec: 7f ff 9e 73 call 400025b8 <.umul>
4001abf0: 90 10 00 1b mov %i3, %o0
4001abf4: d6 07 bf f0 ld [ %fp + -16 ], %o3
4001abf8: 83 2a 20 02 sll %o0, 2, %g1
map_index += direction * bits_skipped;
4001abfc: 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;
4001ac00: 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;
4001ac04: 80 a6 e0 00 cmp %i3, 0
4001ac08: 04 80 00 1c ble 4001ac78 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x270>
4001ac0c: ae 05 c0 18 add %l7, %i0, %l7
4001ac10: 80 a4 00 1c cmp %l0, %i4
4001ac14: 04 80 00 03 ble 4001ac20 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
4001ac18: 82 10 20 01 mov 1, %g1
4001ac1c: 82 10 20 00 clr %g1
4001ac20: 10 bf ff d9 b 4001ab84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c>
4001ac24: 84 10 20 00 clr %g2
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ac28: b8 10 20 1f mov 0x1f, %i4
4001ac2c: 10 bf ff bf b 4001ab28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x120>
4001ac30: 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);
4001ac34: 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,
4001ac38: 80 a0 60 00 cmp %g1, 0
4001ac3c: 12 80 00 05 bne 4001ac50 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x248>
4001ac40: 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);
4001ac44: c2 05 c0 00 ld [ %l7 ], %g1
4001ac48: 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,
4001ac4c: de 25 c0 00 st %o7, [ %l7 ]
1 << search_offset);
control->free--;
4001ac50: c2 05 a0 10 ld [ %l6 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
4001ac54: 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--;
4001ac58: 82 00 7f ff add %g1, -1, %g1
4001ac5c: c2 25 a0 10 st %g1, [ %l6 + 0x10 ]
*bit = test_bit;
4001ac60: f8 26 40 00 st %i4, [ %i1 ]
*found = true;
4001ac64: 82 10 20 01 mov 1, %g1
4001ac68: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
4001ac6c: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
4001ac70: 81 c7 e0 08 ret
4001ac74: 91 e8 20 00 restore %g0, 0, %o0
4001ac78: 84 10 00 15 mov %l5, %g2
4001ac7c: 80 a4 00 1c cmp %l0, %i4
4001ac80: 14 80 00 04 bg 4001ac90 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x288>
4001ac84: 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;
4001ac88: 10 bf ff c0 b 4001ab88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001ac8c: 92 10 20 1f mov 0x1f, %o1
4001ac90: 82 10 20 00 clr %g1
4001ac94: 10 bf ff bd b 4001ab88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001ac98: 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;
4001ac9c: 83 2a 60 05 sll %o1, 5, %g1
map_offset = rtems_rfs_bitmap_element_bits () - 1;
4001aca0: 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;
4001aca4: 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;
4001aca8: 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;
4001acac: 10 bf ff cf b 4001abe8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e0>
4001acb0: 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))
4001acb4: 80 a0 60 00 cmp %g1, 0
4001acb8: 22 bf ff a7 be,a 4001ab54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x14c>
4001acbc: 86 00 c0 0b add %g3, %o3, %g3
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
4001acc0: ae 05 c0 18 add %l7, %i0, %l7
4001acc4: 80 a4 00 1c cmp %l0, %i4
4001acc8: 04 80 00 03 ble 4001acd4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2cc><== NEVER TAKEN
4001accc: 82 10 20 01 mov 1, %g1
4001acd0: 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))
4001acd4: 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;
4001acd8: 10 bf ff ac b 4001ab88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001acdc: 92 10 20 1f mov 0x1f, %o1
40020198 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
40020198: 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))
4002019c: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
400201a0: 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))
400201a4: 7f ff cf 40 call 40013ea4 <rtems_rfs_trace>
400201a8: 92 10 20 00 clr %o1
400201ac: 80 8a 20 ff btst 0xff, %o0
400201b0: 32 80 00 08 bne,a 400201d0 <rtems_rfs_symlink+0x38> <== NEVER TAKEN
400201b4: 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))
400201b8: c2 06 20 08 ld [ %i0 + 8 ], %g1
400201bc: 80 a7 00 01 cmp %i4, %g1
400201c0: 0a 80 00 22 bcs 40020248 <rtems_rfs_symlink+0xb0> <== ALWAYS TAKEN
400201c4: 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;
}
400201c8: 81 c7 e0 08 ret
400201cc: 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);
400201d0: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
400201d4: 40 00 0f 6a call 40023f7c <printf> <== NOT EXECUTED
400201d8: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400381f8 <CSWTCH.2+0x1608><== NOT EXECUTED
400201dc: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
400201e0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400201e4: 04 80 00 08 ble 40020204 <rtems_rfs_symlink+0x6c> <== NOT EXECUTED
400201e8: a2 06 40 1a add %i1, %i2, %l1 <== NOT EXECUTED
printf ("%c", name[c]);
400201ec: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
400201f0: 40 00 0f cd call 40024124 <putchar> <== NOT EXECUTED
400201f4: 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++)
400201f8: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED
400201fc: 32 bf ff fd bne,a 400201f0 <rtems_rfs_symlink+0x58> <== NOT EXECUTED
40020200: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
40020204: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
40020208: 40 00 0f 5d call 40023f7c <printf> <== NOT EXECUTED
4002020c: 90 12 22 20 or %o0, 0x220, %o0 ! 40038220 <CSWTCH.2+0x1630><== NOT EXECUTED
40020210: b4 10 00 1b mov %i3, %i2 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
40020214: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40020218: 04 bf ff e8 ble 400201b8 <rtems_rfs_symlink+0x20> <== NOT EXECUTED
4002021c: a0 07 00 1b add %i4, %i3, %l0 <== NOT EXECUTED
printf ("%c", link[c]);
40020220: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
40020224: 40 00 0f c0 call 40024124 <putchar> <== NOT EXECUTED
40020228: 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++)
4002022c: 80 a6 80 10 cmp %i2, %l0 <== NOT EXECUTED
40020230: 32 bf ff fd bne,a 40020224 <rtems_rfs_symlink+0x8c> <== NOT EXECUTED
40020234: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
40020238: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
4002023c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40020240: 1a bf ff e2 bcc 400201c8 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
40020244: b4 10 20 5b mov 0x5b, %i2 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
40020248: 40 00 13 be call 40025140 <strlen>
4002024c: 90 10 00 19 mov %i1, %o0
40020250: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
40020254: 82 07 bf 74 add %fp, -140, %g1
40020258: 96 10 00 08 mov %o0, %o3
4002025c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40020260: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
40020264: 90 10 00 18 mov %i0, %o0
40020268: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4002026c: 94 10 00 19 mov %i1, %o2
40020270: 9a 10 20 01 mov 1, %o5
40020274: 19 00 00 28 sethi %hi(0xa000), %o4
40020278: 7f ff c9 b6 call 40012950 <rtems_rfs_inode_create>
4002027c: 98 13 21 ff or %o4, 0x1ff, %o4 ! a1ff <PROM_START+0xa1ff>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
40020280: b4 92 20 00 orcc %o0, 0, %i2
40020284: 14 bf ff d1 bg 400201c8 <rtems_rfs_symlink+0x30> <== NEVER TAKEN
40020288: d2 07 bf 74 ld [ %fp + -140 ], %o1
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4002028c: 90 10 00 18 mov %i0, %o0
40020290: 94 07 bf 88 add %fp, -120, %o2
40020294: 7f ff c8 5d call 40012408 <rtems_rfs_inode_open>
40020298: 96 10 20 01 mov 1, %o3
if (rc > 0)
4002029c: b4 92 20 00 orcc %o0, 0, %i2
400202a0: 14 bf ff ca bg 400201c8 <rtems_rfs_symlink+0x30> <== NEVER TAKEN
400202a4: 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)
400202a8: 38 80 00 20 bgu,a 40020328 <rtems_rfs_symlink+0x190> <== NEVER TAKEN
400202ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
400202b0: d0 07 bf 94 ld [ %fp + -108 ], %o0
400202b4: 92 10 20 00 clr %o1
400202b8: 94 10 20 14 mov 0x14, %o2
400202bc: 40 00 0e b2 call 40023d84 <memset>
400202c0: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
400202c4: d0 07 bf 94 ld [ %fp + -108 ], %o0
400202c8: 92 10 00 1b mov %i3, %o1
400202cc: 90 02 20 1c add %o0, 0x1c, %o0
400202d0: 40 00 0e 1e call 40023b48 <memcpy>
400202d4: 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);
400202d8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400202dc: c0 28 60 0c clrb [ %g1 + 0xc ]
400202e0: c2 07 bf 94 ld [ %fp + -108 ], %g1
400202e4: c0 28 60 0d clrb [ %g1 + 0xd ]
400202e8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400202ec: c0 28 60 0e clrb [ %g1 + 0xe ]
400202f0: c2 07 bf 94 ld [ %fp + -108 ], %g1
400202f4: 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);
400202f8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400202fc: 85 37 20 08 srl %i4, 8, %g2
40020300: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
40020304: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
40020308: 90 10 00 18 mov %i0, %o0
4002030c: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40020310: 82 10 20 01 mov 1, %g1
40020314: 92 07 bf 88 add %fp, -120, %o1
40020318: 7f ff c8 b4 call 400125e8 <rtems_rfs_inode_close>
4002031c: c2 2f bf 98 stb %g1, [ %fp + -104 ]
40020320: 10 bf ff aa b 400201c8 <rtems_rfs_symlink+0x30>
40020324: 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);
40020328: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4002032c: 7f ff ec b9 call 4001b610 <rtems_rfs_block_map_open> <== NOT EXECUTED
40020330: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
40020334: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
40020338: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4002033c: 04 80 00 05 ble 40020350 <rtems_rfs_symlink+0x1b8> <== NOT EXECUTED
40020340: 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);
40020344: 7f ff c8 a9 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020348: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4002034c: 30 bf ff 9f b,a 400201c8 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
40020350: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40020354: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40020358: 7f ff ee 07 call 4001bb74 <rtems_rfs_block_map_grow> <== NOT EXECUTED
4002035c: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
40020360: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
40020364: 04 80 00 07 ble 40020380 <rtems_rfs_symlink+0x1e8> <== NOT EXECUTED
40020368: 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);
4002036c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020370: 7f ff ed 09 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
40020374: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40020378: 10 bf ff f3 b 40020344 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
4002037c: 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;
40020380: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
40020384: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
40020388: 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);
4002038c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020390: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
40020394: 7f ff f0 a3 call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40020398: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
4002039c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
400203a0: 14 bf ff f4 bg 40020370 <rtems_rfs_symlink+0x1d8> <== NOT EXECUTED
400203a4: 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);
400203a8: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
400203ac: 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);
400203b0: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
400203b4: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
400203b8: 40 00 0e 73 call 40023d84 <memset> <== NOT EXECUTED
400203bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
400203c0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400203c4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400203c8: 40 00 0d e0 call 40023b48 <memcpy> <== NOT EXECUTED
400203cc: 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);
400203d0: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
400203d4: 7f ff f0 19 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400203d8: 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);
400203dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
400203e0: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
400203e4: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
400203e8: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
400203ec: 7f ff ec ea call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
400203f0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
400203f4: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
400203f8: 04 bf ff c0 ble 400202f8 <rtems_rfs_symlink+0x160> <== NOT EXECUTED
400203fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020400: 30 bf ff d1 b,a 40020344 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
40020404 <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)
{
40020404: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
40020408: 90 10 20 04 mov 4, %o0
4002040c: 7f ff ce a6 call 40013ea4 <rtems_rfs_trace>
40020410: 92 10 20 00 clr %o1
40020414: 80 8a 20 ff btst 0xff, %o0
40020418: 12 80 00 17 bne 40020474 <rtems_rfs_symlink_read+0x70> <== NEVER TAKEN
4002041c: 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);
40020420: 90 10 00 18 mov %i0, %o0
40020424: 92 10 00 19 mov %i1, %o1
40020428: 94 07 bf 88 add %fp, -120, %o2
4002042c: 7f ff c7 f7 call 40012408 <rtems_rfs_inode_open>
40020430: 96 10 20 01 mov 1, %o3
if (rc)
40020434: ba 92 20 00 orcc %o0, 0, %i5
40020438: 12 80 00 0d bne 4002046c <rtems_rfs_symlink_read+0x68> <== NEVER TAKEN
4002043c: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
40020440: 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);
40020444: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
40020448: 85 28 a0 08 sll %g2, 8, %g2
4002044c: 84 08 80 01 and %g2, %g1, %g2
40020450: 03 00 00 28 sethi %hi(0xa000), %g1
40020454: 80 a0 80 01 cmp %g2, %g1
40020458: 02 80 00 0c be 40020488 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
4002045c: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &inode);
40020460: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40020464: 7f ff c8 61 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020468: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
4002046c: 81 c7 e0 08 ret
40020470: 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);
40020474: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
40020478: 40 00 0e c1 call 40023f7c <printf> <== NOT EXECUTED
4002047c: 90 12 22 28 or %o0, 0x228, %o0 ! 40038228 <CSWTCH.2+0x1638><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
40020480: 10 bf ff e9 b 40020424 <rtems_rfs_symlink_read+0x20> <== NOT EXECUTED
40020484: 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);
40020488: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4002048c: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
40020490: 95 2a a0 08 sll %o2, 8, %o2
40020494: 94 10 40 0a or %g1, %o2, %o2
40020498: 80 a2 80 1b cmp %o2, %i3
4002049c: 38 80 00 02 bgu,a 400204a4 <rtems_rfs_symlink_read+0xa0>
400204a0: 94 10 00 1b mov %i3, %o2
400204a4: 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);
400204a8: c8 0a 60 0c ldub [ %o1 + 0xc ], %g4
400204ac: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
400204b0: c6 0a 60 0f ldub [ %o1 + 0xf ], %g3
400204b4: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
400204b8: 89 29 20 18 sll %g4, 0x18, %g4
400204bc: 85 28 a0 10 sll %g2, 0x10, %g2
400204c0: 83 28 60 08 sll %g1, 8, %g1
400204c4: 84 11 00 02 or %g4, %g2, %g2
400204c8: 84 10 80 03 or %g2, %g3, %g2
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
400204cc: 80 90 80 01 orcc %g2, %g1, %g0
400204d0: 12 80 00 0a bne 400204f8 <rtems_rfs_symlink_read+0xf4> <== NEVER TAKEN
400204d4: 90 10 00 18 mov %i0, %o0
{
memcpy (path, inode.node->data.name, *length);
400204d8: 90 10 00 1a mov %i2, %o0
400204dc: 40 00 0d 9b call 40023b48 <memcpy>
400204e0: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
400204e4: 90 10 00 18 mov %i0, %o0
400204e8: 7f ff c8 40 call 400125e8 <rtems_rfs_inode_close>
400204ec: 92 07 bf 88 add %fp, -120, %o1
400204f0: 10 bf ff df b 4002046c <rtems_rfs_symlink_read+0x68>
400204f4: 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);
400204f8: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
400204fc: 7f ff ec 45 call 4001b610 <rtems_rfs_block_map_open> <== NOT EXECUTED
40020500: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
40020504: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
if (rc > 0)
40020508: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4002050c: 04 80 00 05 ble 40020520 <rtems_rfs_symlink_read+0x11c> <== NOT EXECUTED
40020510: 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);
40020514: 7f ff c8 35 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020518: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4002051c: 30 bf ff d4 b,a 4002046c <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);
40020520: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40020524: 94 10 20 00 clr %o2 <== NOT EXECUTED
40020528: 96 10 20 00 clr %o3 <== NOT EXECUTED
4002052c: 7f ff ed 68 call 4001bacc <rtems_rfs_block_map_seek> <== NOT EXECUTED
40020530: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
40020534: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40020538: 04 80 00 09 ble 4002055c <rtems_rfs_symlink_read+0x158> <== NOT EXECUTED
4002053c: 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);
40020540: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40020544: 7f ff ec 94 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
40020548: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4002054c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020550: 7f ff c8 26 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020554: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40020558: 30 bf ff c5 b,a 4002046c <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;
4002055c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
40020560: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
40020564: 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);
40020568: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4002056c: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
40020570: 7f ff f0 2c call 4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40020574: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
40020578: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4002057c: 34 bf ff f2 bg,a 40020544 <rtems_rfs_symlink_read+0x140> <== NOT EXECUTED
40020580: 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);
40020584: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
40020588: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4002058c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
40020590: 40 00 0d 6e call 40023b48 <memcpy> <== NOT EXECUTED
40020594: 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);
40020598: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4002059c: 7f ff ef a7 call 4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400205a0: 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);
400205a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
400205a8: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
400205ac: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
400205b0: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
400205b4: 7f ff ec 78 call 4001b794 <rtems_rfs_block_map_close> <== NOT EXECUTED
400205b8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
400205bc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400205c0: 04 bf ff c9 ble 400204e4 <rtems_rfs_symlink_read+0xe0> <== NOT EXECUTED
400205c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400205c8: 30 bf ff d3 b,a 40020514 <rtems_rfs_symlink_read+0x110> <== NOT EXECUTED
40013ee4 <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;
40013ee4: 03 10 01 26 sethi %hi(0x40049800), %g1 <== NOT EXECUTED
40013ee8: c4 18 61 f8 ldd [ %g1 + 0x1f8 ], %g2 ! 400499f8 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
40013eec: 98 28 80 08 andn %g2, %o0, %o4 <== NOT EXECUTED
40013ef0: 9a 28 c0 09 andn %g3, %o1, %o5 <== NOT EXECUTED
return state;
}
40013ef4: 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;
40013ef8: d8 38 61 f8 std %o4, [ %g1 + 0x1f8 ] <== NOT EXECUTED
return state;
}
40013efc: 81 c3 e0 08 retl <== NOT EXECUTED
40013f00: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40013ec4 <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;
40013ec4: 03 10 01 26 sethi %hi(0x40049800), %g1 <== NOT EXECUTED
40013ec8: c4 18 61 f8 ldd [ %g1 + 0x1f8 ], %g2 ! 400499f8 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
40013ecc: 98 12 00 02 or %o0, %g2, %o4 <== NOT EXECUTED
40013ed0: 9a 12 40 03 or %o1, %g3, %o5 <== NOT EXECUTED
return state;
}
40013ed4: 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;
40013ed8: d8 38 61 f8 std %o4, [ %g1 + 0x1f8 ] <== NOT EXECUTED
return state;
}
40013edc: 81 c3 e0 08 retl <== NOT EXECUTED
40013ee0: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40013f04 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
40013f04: 9d e3 bf 00 save %sp, -256, %sp <== NOT EXECUTED
const char* table[] =
40013f08: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
40013f0c: a8 07 bf 64 add %fp, -156, %l4 <== NOT EXECUTED
40013f10: 92 12 63 0c or %o1, 0x30c, %o1 <== NOT EXECUTED
40013f14: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
40013f18: 40 00 3f 0c call 40023b48 <memcpy> <== NOT EXECUTED
40013f1c: 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++)
40013f20: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
40013f24: 04 80 00 3f ble 40014020 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40013f28: 01 00 00 00 nop <== NOT EXECUTED
{
if (argv[arg][0] == '-')
40013f2c: e4 06 60 04 ld [ %i1 + 4 ], %l2 <== NOT EXECUTED
40013f30: c2 4c 80 00 ldsb [ %l2 ], %g1 <== NOT EXECUTED
40013f34: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40013f38: 02 80 00 6e be 400140f0 <rtems_rfs_trace_shell_command+0x1ec><== NOT EXECUTED
40013f3c: 2f 10 01 26 sethi %hi(0x40049800), %l7 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40013f40: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
40013f44: f8 1d e1 f8 ldd [ %l7 + 0x1f8 ], %i4 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
40013f48: 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;
40013f4c: b4 10 20 00 clr %i2 <== NOT EXECUTED
40013f50: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
40013f54: a0 10 20 00 clr %l0 <== NOT EXECUTED
40013f58: a2 10 20 00 clr %l1 <== NOT EXECUTED
40013f5c: 10 80 00 10 b 40013f9c <rtems_rfs_trace_shell_command+0x98><== NOT EXECUTED
40013f60: ae 15 e1 f8 or %l7, 0x1f8, %l7 <== NOT EXECUTED
40013f64: 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;
40013f68: aa 10 20 00 clr %l5 <== NOT EXECUTED
40013f6c: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
40013f70: 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++)
40013f74: a6 04 e0 01 inc %l3 <== NOT EXECUTED
40013f78: 80 a4 c0 18 cmp %l3, %i0 <== NOT EXECUTED
40013f7c: 02 80 00 29 be 40014020 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40013f80: 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[])
40013f84: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
40013f88: e4 06 40 01 ld [ %i1 + %g1 ], %l2 <== NOT EXECUTED
40013f8c: c2 4c 80 00 ldsb [ %l2 ], %g1 <== NOT EXECUTED
40013f90: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40013f94: 22 80 00 58 be,a 400140f4 <rtems_rfs_trace_shell_command+0x1f0><== NOT EXECUTED
40013f98: c2 4c a0 01 ldsb [ %l2 + 1 ], %g1 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
40013f9c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40013fa0: 13 10 00 d1 sethi %hi(0x40034400), %o1 <== NOT EXECUTED
40013fa4: 40 00 42 7d call 40024998 <strcmp> <== NOT EXECUTED
40013fa8: 92 12 60 08 or %o1, 8, %o1 ! 40034408 <__FUNCTION__.6193+0x340><== NOT EXECUTED
40013fac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013fb0: 22 80 00 02 be,a 40013fb8 <rtems_rfs_trace_shell_command+0xb4><== NOT EXECUTED
40013fb4: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
40013fb8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40013fbc: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
40013fc0: 40 00 42 76 call 40024998 <strcmp> <== NOT EXECUTED
40013fc4: 92 12 60 a0 or %o1, 0xa0, %o1 ! 400360a0 <rtems_rfs_rtems_eval_config+0xa0><== NOT EXECUTED
40013fc8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013fcc: 22 bf ff e6 be,a 40013f64 <rtems_rfs_trace_shell_command+0x60><== NOT EXECUTED
40013fd0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
40013fd4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40013fd8: 13 10 00 d8 sethi %hi(0x40036000), %o1 <== NOT EXECUTED
40013fdc: 40 00 42 6f call 40024998 <strcmp> <== NOT EXECUTED
40013fe0: 92 12 60 a8 or %o1, 0xa8, %o1 ! 400360a8 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
40013fe4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013fe8: 12 80 00 13 bne 40014034 <rtems_rfs_trace_shell_command+0x130><== NOT EXECUTED
40013fec: ac 10 20 00 clr %l6 <== NOT EXECUTED
{
if (set)
40013ff0: 80 8d 60 ff btst 0xff, %l5 <== NOT EXECUTED
40013ff4: 22 80 00 23 be,a 40014080 <rtems_rfs_trace_shell_command+0x17c><== NOT EXECUTED
40013ff8: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
40013ffc: b8 3e a0 00 xnor %i2, 0, %i4 <== NOT EXECUTED
40014000: ba 3e e0 00 xnor %i3, 0, %i5 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
40014004: 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;
40014008: 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++)
4001400c: 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;
40014010: 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++)
40014014: 80 a4 c0 18 cmp %l3, %i0 <== NOT EXECUTED
40014018: 12 bf ff db bne 40013f84 <rtems_rfs_trace_shell_command+0x80><== NOT EXECUTED
4001401c: 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;
40014020: 81 c7 e0 08 ret <== NOT EXECUTED
40014024: 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++)
40014028: 80 a5 a0 27 cmp %l6, 0x27 <== NOT EXECUTED
4001402c: 22 80 00 11 be,a 40014070 <rtems_rfs_trace_shell_command+0x16c><== NOT EXECUTED
40014030: 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[])
40014034: 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)
40014038: d2 05 00 02 ld [ %l4 + %g2 ], %o1 <== NOT EXECUTED
4001403c: 40 00 42 57 call 40024998 <strcmp> <== NOT EXECUTED
40014040: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40014044: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014048: 32 bf ff f8 bne,a 40014028 <rtems_rfs_trace_shell_command+0x124><== NOT EXECUTED
4001404c: ac 05 a0 01 inc %l6 <== NOT EXECUTED
{
if (set)
40014050: 80 8d 60 ff btst 0xff, %l5 <== NOT EXECUTED
40014054: 02 80 00 10 be 40014094 <rtems_rfs_trace_shell_command+0x190><== NOT EXECUTED
40014058: 80 8d a0 20 btst 0x20, %l6 <== NOT EXECUTED
set_value = 1ULL << t;
4001405c: 12 80 00 1e bne 400140d4 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
40014060: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40014064: a0 10 20 00 clr %l0 <== NOT EXECUTED
40014068: a3 28 40 16 sll %g1, %l6, %l1 <== NOT EXECUTED
4001406c: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
40014070: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
40014074: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
40014078: 10 bf ff bf b 40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
4001407c: 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)
40014080: b8 10 20 00 clr %i4 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
40014084: 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)
40014088: ba 10 20 00 clr %i5 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
4001408c: 10 bf ff ba b 40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
40014090: 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;
40014094: 12 80 00 09 bne 400140b8 <rtems_rfs_trace_shell_command+0x1b4><== NOT EXECUTED
40014098: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001409c: b4 10 20 00 clr %i2 <== NOT EXECUTED
400140a0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
400140a4: b7 28 40 16 sll %g1, %l6, %i3 <== NOT EXECUTED
400140a8: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
400140ac: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
400140b0: 10 bf ff b1 b 40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400140b4: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
400140b8: b6 10 20 00 clr %i3 <== NOT EXECUTED
400140bc: b5 28 40 16 sll %g1, %l6, %i2 <== NOT EXECUTED
400140c0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
400140c4: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
400140c8: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
400140cc: 10 bf ff aa b 40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400140d0: 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;
400140d4: a2 10 20 00 clr %l1 <== NOT EXECUTED
400140d8: a1 28 40 16 sll %g1, %l6, %l0 <== NOT EXECUTED
400140dc: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
400140e0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
400140e4: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
400140e8: 10 bf ff a3 b 40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400140ec: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
400140f0: c2 4c a0 01 ldsb [ %l2 + 1 ], %g1 <== NOT EXECUTED
400140f4: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
400140f8: 02 80 00 09 be 4001411c <rtems_rfs_trace_shell_command+0x218><== NOT EXECUTED
400140fc: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
40014100: 02 80 00 0e be 40014138 <rtems_rfs_trace_shell_command+0x234><== NOT EXECUTED
40014104: 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");
40014108: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
4001410c: 40 00 40 34 call 400241dc <puts> <== NOT EXECUTED
40014110: 90 12 20 88 or %o0, 0x88, %o0 ! 40036088 <rtems_rfs_rtems_eval_config+0x88><== NOT EXECUTED
40014114: 81 c7 e0 08 ret <== NOT EXECUTED
40014118: 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]);
4001411c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40014120: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
return 0;
40014124: 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]);
40014128: 40 00 3f 95 call 40023f7c <printf> <== NOT EXECUTED
4001412c: 90 12 20 30 or %o0, 0x30, %o0 <== NOT EXECUTED
40014130: 81 c7 e0 08 ret <== NOT EXECUTED
40014134: 81 e8 00 00 restore <== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
40014138: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001413c: 11 10 00 d8 sethi %hi(0x40036000), %o0 <== NOT EXECUTED
40014140: 3b 10 00 d8 sethi %hi(0x40036000), %i5 <== NOT EXECUTED
40014144: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
40014148: 40 00 3f 8d call 40023f7c <printf> <== NOT EXECUTED
4001414c: b8 10 00 1e mov %fp, %i4 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
40014150: ba 17 60 80 or %i5, 0x80, %i5 <== NOT EXECUTED
40014154: d2 05 00 00 ld [ %l4 ], %o1 <== NOT EXECUTED
40014158: 40 00 3f 89 call 40023f7c <printf> <== NOT EXECUTED
4001415c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40014160: 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++)
40014164: 80 a5 00 1c cmp %l4, %i4 <== NOT EXECUTED
40014168: 32 bf ff fc bne,a 40014158 <rtems_rfs_trace_shell_command+0x254><== NOT EXECUTED
4001416c: 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;
40014170: 81 c7 e0 08 ret <== NOT EXECUTED
40014174: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40014178: 40 01 51 f4 call 40068948 <__end+0x1dff8> <== NOT EXECUTED
4001417c: 40 01 53 90 call 40068fbc <__end+0x1e66c> <== NOT EXECUTED
40014180: 40 01 53 88 call 40068fa0 <__end+0x1e650> <== NOT EXECUTED
40014184: 40 01 53 74 call 40068f54 <__end+0x1e604> <== NOT EXECUTED
40014188: 40 01 53 74 call 40068f58 <__end+0x1e608> <== NOT EXECUTED
4001418c: 40 01 53 74 call 40068f5c <__end+0x1e60c> <== NOT EXECUTED
40014190: 40 01 53 74 call 40068f60 <__end+0x1e610> <== NOT EXECUTED
40014194: 40 01 53 40 call 40068e94 <__end+0x1e544> <== NOT EXECUTED
40014198: 40 01 53 2c call 40068e48 <__end+0x1e4f8> <== NOT EXECUTED
4001419c: 40 01 53 2c call 40068e4c <__end+0x1e4fc> <== NOT EXECUTED
400141a0: 40 01 53 2c call 40068e50 <__end+0x1e500> <== NOT EXECUTED
400141a4: 40 01 52 3c call 40068a94 <__end+0x1e144> <== NOT EXECUTED
400141a8: 40 01 52 2c call 40068a58 <__end+0x1e108> <== NOT EXECUTED
400141ac: 40 01 52 2c call 40068a5c <__end+0x1e10c> <== NOT EXECUTED
400141b0: 40 01 53 08 call 40068dd0 <__end+0x1e480> <== NOT EXECUTED
400141b4: 40 01 53 08 call 40068dd4 <__end+0x1e484> <== NOT EXECUTED
400141b8: 40 01 53 08 call 40068dd8 <__end+0x1e488> <== NOT EXECUTED
400141bc: 40 01 53 08 call 40068ddc <__end+0x1e48c> <== NOT EXECUTED
400141c0: 40 01 52 d4 call 40068d10 <__end+0x1e3c0> <== NOT EXECUTED
400141c4: 40 01 52 c0 call 40068cc4 <__end+0x1e374> <== NOT EXECUTED
400141c8: 40 01 52 c0 call 40068cc8 <__end+0x1e378> <== NOT EXECUTED
400141cc: 40 01 52 c0 call 40068ccc <__end+0x1e37c> <== NOT EXECUTED
400141d0: 40 01 68 40 call 4006e2d0 <__end+0x23980> <== NOT EXECUTED
400141d4: 40 01 68 40 call 4006e2d4 <__end+0x23984> <== NOT EXECUTED
400141d8: 40 01 69 68 call 4006e778 <__end+0x23e28> <== NOT EXECUTED
400141dc: 40 01 69 90 call 4006e81c <__end+0x23ecc> <== NOT EXECUTED
400141e0: 40 01 69 90 call 4006e820 <__end+0x23ed0> <== NOT EXECUTED
400141e4: 40 01 69 90 call 4006e824 <__end+0x23ed4> <== NOT EXECUTED
400141e8: 40 01 68 40 call 4006e2e8 <__end+0x23998> <== NOT EXECUTED
400141ec: 40 01 69 58 call 4006e74c <__end+0x23dfc> <== NOT EXECUTED
400141f0: 40 01 69 50 call 4006e730 <__end+0x23de0> <== NOT EXECUTED
400141f4: 40 01 69 98 call 4006e854 <__end+0x23f04> <== NOT EXECUTED
400141f8: 40 01 68 40 call 4006e2f8 <__end+0x239a8> <== NOT EXECUTED
4001fd68 <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)
{
4001fd68: 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))
4001fd6c: 90 10 20 00 clr %o0
4001fd70: 7f ff d0 4d call 40013ea4 <rtems_rfs_trace>
4001fd74: 13 00 80 00 sethi %hi(0x2000000), %o1
4001fd78: 80 8a 20 ff btst 0xff, %o0
4001fd7c: 12 80 00 4a bne 4001fea4 <rtems_rfs_unlink+0x13c> <== NEVER TAKEN
4001fd80: 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);
4001fd84: 90 10 00 18 mov %i0, %o0
4001fd88: 92 10 00 1a mov %i2, %o1
4001fd8c: 94 07 bf d8 add %fp, -40, %o2
4001fd90: 7f ff c9 9e call 40012408 <rtems_rfs_inode_open>
4001fd94: 96 10 20 01 mov 1, %o3
if (rc)
4001fd98: ba 92 20 00 orcc %o0, 0, %i5
4001fd9c: 12 80 00 19 bne 4001fe00 <rtems_rfs_unlink+0x98> <== NEVER TAKEN
4001fda0: 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));
4001fda4: 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);
4001fda8: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001fdac: 83 28 60 08 sll %g1, 8, %g1
4001fdb0: 82 08 40 02 and %g1, %g2, %g1
4001fdb4: 05 00 00 10 sethi %hi(0x4000), %g2
4001fdb8: 82 18 40 02 xor %g1, %g2, %g1
if (dir)
4001fdbc: 80 a0 00 01 cmp %g0, %g1
4001fdc0: a0 60 3f ff subx %g0, -1, %l0
4001fdc4: 80 a4 20 00 cmp %l0, 0
4001fdc8: 02 80 00 12 be 4001fe10 <rtems_rfs_unlink+0xa8>
4001fdcc: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
4001fdd0: 12 80 00 0e bne 4001fe08 <rtems_rfs_unlink+0xa0> <== ALWAYS TAKEN
4001fdd4: 80 a7 20 01 cmp %i4, 1
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001fdd8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001fddc: 7f ff d0 32 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fde0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001fde4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fde8: 12 80 00 5a bne 4001ff50 <rtems_rfs_unlink+0x1e8> <== NOT EXECUTED
4001fdec: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
4001fdf0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001fdf4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001fdf8: 7f ff c9 fc call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fdfc: 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;
}
4001fe00: 81 c7 e0 08 ret
4001fe04: 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)
4001fe08: 02 80 00 3f be 4001ff04 <rtems_rfs_unlink+0x19c> <== ALWAYS TAKEN
4001fe0c: 90 10 00 18 mov %i0, %o0
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4001fe10: 90 10 00 18 mov %i0, %o0
4001fe14: 92 10 00 19 mov %i1, %o1
4001fe18: 94 07 bf b0 add %fp, -80, %o2
4001fe1c: 7f ff c9 7b call 40012408 <rtems_rfs_inode_open>
4001fe20: 96 10 20 01 mov 1, %o3
if (rc)
4001fe24: ba 92 20 00 orcc %o0, 0, %i5
4001fe28: 12 80 00 25 bne 4001febc <rtems_rfs_unlink+0x154> <== NEVER TAKEN
4001fe2c: 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);
4001fe30: 90 10 00 18 mov %i0, %o0
4001fe34: 92 07 bf b0 add %fp, -80, %o1
4001fe38: 94 10 00 1a mov %i2, %o2
4001fe3c: 7f ff f6 43 call 4001d748 <rtems_rfs_dir_del_entry>
4001fe40: 96 10 00 1b mov %i3, %o3
if (rc > 0)
4001fe44: ba 92 20 00 orcc %o0, 0, %i5
4001fe48: 04 80 00 46 ble 4001ff60 <rtems_rfs_unlink+0x1f8> <== ALWAYS TAKEN
4001fe4c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001fe50: 7f ff d0 15 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fe54: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001fe58: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fe5c: 02 80 00 0a be 4001fe84 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
4001fe60: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
4001fe64: 40 00 14 90 call 400250a4 <strerror> <== NOT EXECUTED
4001fe68: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001fe6c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001fe70: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001fe74: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001fe78: 40 00 10 41 call 40023f7c <printf> <== NOT EXECUTED
4001fe7c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400380c8 <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);
4001fe80: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001fe84: 7f ff c9 d9 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fe88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001fe8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001fe90: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
4001fe94: 7f ff c9 d5 call 400125e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001fe98: 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;
}
4001fe9c: 81 c7 e0 08 ret <== NOT EXECUTED
4001fea0: 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);
4001fea4: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001fea8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001feac: 40 00 10 34 call 40023f7c <printf> <== NOT EXECUTED
4001feb0: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4001feb4: 10 bf ff b5 b 4001fd88 <rtems_rfs_unlink+0x20> <== NOT EXECUTED
4001feb8: 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))
4001febc: 7f ff cf fa call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fec0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001fec4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fec8: 22 80 00 0a be,a 4001fef0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
4001fecc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
4001fed0: 40 00 14 75 call 400250a4 <strerror> <== NOT EXECUTED
4001fed4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001fed8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001fedc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001fee0: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001fee4: 40 00 10 26 call 40023f7c <printf> <== NOT EXECUTED
4001fee8: 90 12 20 98 or %o0, 0x98, %o0 ! 40038098 <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);
4001feec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001fef0: 92 07 bf d8 add %fp, -40, %o1
4001fef4: 7f ff c9 bd call 400125e8 <rtems_rfs_inode_close>
4001fef8: 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;
}
4001fefc: 81 c7 e0 08 ret
4001ff00: 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);
4001ff04: 7f ff f8 14 call 4001df54 <rtems_rfs_dir_empty>
4001ff08: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4001ff0c: ba 92 20 00 orcc %o0, 0, %i5
4001ff10: 04 bf ff c0 ble 4001fe10 <rtems_rfs_unlink+0xa8>
4001ff14: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001ff18: 7f ff cf e3 call 40013ea4 <rtems_rfs_trace>
4001ff1c: 13 00 80 00 sethi %hi(0x2000000), %o1
4001ff20: 80 8a 20 ff btst 0xff, %o0
4001ff24: 22 bf ff f3 be,a 4001fef0 <rtems_rfs_unlink+0x188> <== ALWAYS TAKEN
4001ff28: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4001ff2c: 40 00 14 5e call 400250a4 <strerror> <== NOT EXECUTED
4001ff30: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ff34: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001ff38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001ff3c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001ff40: 40 00 10 0f call 40023f7c <printf> <== NOT EXECUTED
4001ff44: 90 12 20 78 or %o0, 0x78, %o0 ! 40038078 <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);
4001ff48: 10 bf ff ea b 4001fef0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
4001ff4c: 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");
4001ff50: 40 00 10 a3 call 400241dc <puts> <== NOT EXECUTED
4001ff54: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4001ff58: 10 bf ff a7 b 4001fdf4 <rtems_rfs_unlink+0x8c> <== NOT EXECUTED
4001ff5c: 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);
4001ff60: c4 07 bf e4 ld [ %fp + -28 ], %g2
if (links == 0xffff)
links = 0;
4001ff64: 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);
4001ff68: c2 08 80 00 ldub [ %g2 ], %g1
4001ff6c: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
4001ff70: 83 28 60 08 sll %g1, 8, %g1
4001ff74: 82 10 40 02 or %g1, %g2, %g1
if (links == 0xffff)
4001ff78: 85 28 60 10 sll %g1, 0x10, %g2
4001ff7c: 85 30 a0 10 srl %g2, 0x10, %g2
links = 0;
4001ff80: 84 38 c0 02 xnor %g3, %g2, %g2
4001ff84: 80 a0 00 02 cmp %g0, %g2
4001ff88: 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))
4001ff8c: 13 00 80 00 sethi %hi(0x2000000), %o1
4001ff90: 7f ff cf c5 call 40013ea4 <rtems_rfs_trace>
4001ff94: ba 08 40 1d and %g1, %i5, %i5
4001ff98: 80 8a 20 ff btst 0xff, %o0
4001ff9c: 12 80 00 22 bne 40020024 <rtems_rfs_unlink+0x2bc> <== NEVER TAKEN
4001ffa0: b9 2f 60 10 sll %i5, 0x10, %i4
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
4001ffa4: b9 37 20 10 srl %i4, 0x10, %i4
4001ffa8: 80 a7 20 01 cmp %i4, 1
4001ffac: 08 80 00 39 bleu 40020090 <rtems_rfs_unlink+0x328>
4001ffb0: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
4001ffb4: 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);
4001ffb8: 85 37 60 08 srl %i5, 8, %g2
4001ffbc: c4 28 40 00 stb %g2, [ %g1 ]
4001ffc0: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001ffc4: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ffc8: 82 10 20 01 mov 1, %g1
4001ffcc: 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);
4001ffd0: 90 07 bf b0 add %fp, -80, %o0
4001ffd4: 92 10 20 01 mov 1, %o1
4001ffd8: 7f ff c9 df call 40012754 <rtems_rfs_inode_time_stamp_now>
4001ffdc: 94 10 20 01 mov 1, %o2
if (rc > 0)
4001ffe0: ba 92 20 00 orcc %o0, 0, %i5
4001ffe4: 04 80 00 17 ble 40020040 <rtems_rfs_unlink+0x2d8> <== ALWAYS TAKEN
4001ffe8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4001ffec: 7f ff cf ae call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4001fff0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
4001fff4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001fff8: 22 bf ff a3 be,a 4001fe84 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
4001fffc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
40020000: 40 00 14 29 call 400250a4 <strerror> <== NOT EXECUTED
40020004: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020008: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4002000c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020010: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
40020014: 40 00 0f da call 40023f7c <printf> <== NOT EXECUTED
40020018: 90 12 21 50 or %o0, 0x150, %o0 ! 40038150 <CSWTCH.2+0x1560><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
4002001c: 10 bf ff 9a b 4001fe84 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
40020020: 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);
40020024: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40020028: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4002002c: 95 37 20 10 srl %i4, 0x10, %o2 <== NOT EXECUTED
40020030: 40 00 0f d3 call 40023f7c <printf> <== NOT EXECUTED
40020034: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED
if (links > 1)
40020038: 10 bf ff dc b 4001ffa8 <rtems_rfs_unlink+0x240> <== NOT EXECUTED
4002003c: 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);
40020040: 90 10 00 18 mov %i0, %o0
40020044: 7f ff c9 69 call 400125e8 <rtems_rfs_inode_close>
40020048: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
4002004c: ba 92 20 00 orcc %o0, 0, %i5
40020050: 04 80 00 24 ble 400200e0 <rtems_rfs_unlink+0x378> <== ALWAYS TAKEN
40020054: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40020058: 7f ff cf 93 call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
4002005c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40020060: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020064: 22 bf ff a3 be,a 4001fef0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
40020068: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
4002006c: 40 00 14 0e call 400250a4 <strerror> <== NOT EXECUTED
40020070: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020074: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020078: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002007c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
40020080: 40 00 0f bf call 40023f7c <printf> <== NOT EXECUTED
40020084: 90 12 21 88 or %o0, 0x188, %o0 ! 40038188 <CSWTCH.2+0x1598><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
40020088: 10 bf ff 9a b 4001fef0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
4002008c: 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);
40020090: 90 10 00 18 mov %i0, %o0
40020094: 7f ff c9 7b call 40012680 <rtems_rfs_inode_delete>
40020098: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4002009c: ba 92 20 00 orcc %o0, 0, %i5
400200a0: 04 80 00 23 ble 4002012c <rtems_rfs_unlink+0x3c4> <== ALWAYS TAKEN
400200a4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400200a8: 7f ff cf 7f call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400200ac: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400200b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400200b4: 22 bf ff 74 be,a 4001fe84 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
400200b8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
400200bc: 40 00 13 fa call 400250a4 <strerror> <== NOT EXECUTED
400200c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400200c4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400200c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400200cc: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
400200d0: 40 00 0f ab call 40023f7c <printf> <== NOT EXECUTED
400200d4: 90 12 21 20 or %o0, 0x120, %o0 ! 40038120 <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);
400200d8: 10 bf ff 6b b 4001fe84 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
400200dc: 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);
400200e0: 90 10 00 18 mov %i0, %o0
400200e4: 7f ff c9 41 call 400125e8 <rtems_rfs_inode_close>
400200e8: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400200ec: ba 92 20 00 orcc %o0, 0, %i5
400200f0: 04 bf ff 44 ble 4001fe00 <rtems_rfs_unlink+0x98> <== ALWAYS TAKEN
400200f4: 90 10 20 00 clr %o0
400200f8: 7f ff cf 6b call 40013ea4 <rtems_rfs_trace> <== NOT EXECUTED
400200fc: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40020100: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020104: 02 bf ff 3f be 4001fe00 <rtems_rfs_unlink+0x98> <== NOT EXECUTED
40020108: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
4002010c: 40 00 13 e6 call 400250a4 <strerror> <== NOT EXECUTED
40020110: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020114: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020118: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002011c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
40020120: 40 00 0f 97 call 40023f7c <printf> <== NOT EXECUTED
40020124: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 400381c0 <CSWTCH.2+0x15d0><== NOT EXECUTED
40020128: 30 bf ff 36 b,a 4001fe00 <rtems_rfs_unlink+0x98> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
4002012c: 80 a4 20 00 cmp %l0, 0
40020130: 02 bf ff a9 be 4001ffd4 <rtems_rfs_unlink+0x26c>
40020134: 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);
40020138: c4 07 bf bc ld [ %fp + -68 ], %g2
if (links == 0xffff)
4002013c: 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);
40020140: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
40020144: c6 08 80 00 ldub [ %g2 ], %g3
if (links == 0xffff)
40020148: 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);
4002014c: 87 28 e0 08 sll %g3, 8, %g3
40020150: 86 10 c0 01 or %g3, %g1, %g3
if (links == 0xffff)
40020154: 89 28 e0 10 sll %g3, 0x10, %g4
40020158: 89 31 20 10 srl %g4, 0x10, %g4
4002015c: 80 a1 00 1d cmp %g4, %i5
40020160: 02 80 00 0c be 40020190 <rtems_rfs_unlink+0x428> <== NEVER TAKEN
40020164: 82 10 00 03 mov %g3, %g1
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
40020168: 80 a1 20 01 cmp %g4, 1
4002016c: 38 80 00 02 bgu,a 40020174 <rtems_rfs_unlink+0x40c>
40020170: 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);
40020174: 87 30 60 08 srl %g1, 8, %g3
40020178: c6 28 80 00 stb %g3, [ %g2 ]
4002017c: c4 07 bf bc ld [ %fp + -68 ], %g2
40020180: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40020184: 82 10 20 01 mov 1, %g1
40020188: 10 bf ff 92 b 4001ffd0 <rtems_rfs_unlink+0x268>
4002018c: 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;
40020190: 10 bf ff f9 b 40020174 <rtems_rfs_unlink+0x40c> <== NOT EXECUTED
40020194: 82 10 20 00 clr %g1 <== NOT EXECUTED
40023584 <rtems_shell_rfs_format>:
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
40023584: 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));
40023588: c0 27 bf e8 clr [ %fp + -24 ] <== NOT EXECUTED
4002358c: c0 27 bf ec clr [ %fp + -20 ] <== NOT EXECUTED
40023590: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
40023594: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
40023598: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
4002359c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
400235a0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
400235a4: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
400235a8: 37 10 00 87 sethi %hi(0x40021c00), %i3 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
400235ac: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
400235b0: 14 80 00 0a bg 400235d8 <rtems_shell_rfs_format+0x54> <== NOT EXECUTED
400235b4: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
400235b8: 10 80 00 69 b 4002375c <rtems_shell_rfs_format+0x1d8> <== NOT EXECUTED
400235bc: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
400235c0: 12 80 00 55 bne 40023714 <rtems_shell_rfs_format+0x190> <== NOT EXECUTED
400235c4: 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++)
400235c8: ba 07 60 01 inc %i5 <== NOT EXECUTED
400235cc: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
400235d0: 04 80 00 1d ble 40023644 <rtems_shell_rfs_format+0xc0> <== NOT EXECUTED
400235d4: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
400235d8: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
400235dc: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
400235e0: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
400235e4: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
400235e8: 12 bf ff f6 bne 400235c0 <rtems_shell_rfs_format+0x3c> <== NOT EXECUTED
400235ec: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
400235f0: c2 0a 60 01 ldub [ %o1 + 1 ], %g1 <== NOT EXECUTED
400235f4: 82 00 7f b7 add %g1, -73, %g1 <== NOT EXECUTED
400235f8: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
400235fc: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40023600: 08 80 00 08 bleu 40023620 <rtems_shell_rfs_format+0x9c> <== NOT EXECUTED
40023604: 84 16 e3 58 or %i3, 0x358, %g2 <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
40023608: 11 10 01 70 sethi %hi(0x4005c000), %o0 <== NOT EXECUTED
return 1;
4002360c: 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]);
40023610: 40 00 72 25 call 4003fea4 <printf> <== NOT EXECUTED
40023614: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
40023618: 81 c7 e0 08 ret <== NOT EXECUTED
4002361c: 81 e8 00 00 restore <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
40023620: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
40023624: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED
40023628: 81 c0 40 00 jmp %g1 <== NOT EXECUTED
4002362c: 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++)
40023630: ba 07 60 01 inc %i5 <== NOT EXECUTED
40023634: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
40023638: 14 bf ff e8 bg 400235d8 <rtems_shell_rfs_format+0x54> <== NOT EXECUTED
4002363c: f4 2f bf fd stb %i2, [ %fp + -3 ] <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
40023640: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40023644: 02 80 00 45 be 40023758 <rtems_shell_rfs_format+0x1d4> <== NOT EXECUTED
40023648: 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)
4002364c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40023650: 40 00 3b 15 call 400322a4 <rtems_rfs_format> <== NOT EXECUTED
40023654: b0 10 20 00 clr %i0 <== NOT EXECUTED
40023658: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002365c: 06 80 00 34 bl 4002372c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
40023660: 01 00 00 00 nop <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
40023664: 81 c7 e0 08 ret <== NOT EXECUTED
40023668: 81 e8 00 00 restore <== NOT EXECUTED
case 'v':
config.verbose = true;
break;
case 's':
arg++;
4002366c: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
40023670: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
40023674: 04 80 00 45 ble 40023788 <rtems_shell_rfs_format+0x204> <== NOT EXECUTED
40023678: 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);
4002367c: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40023680: 92 10 20 00 clr %o1 <== NOT EXECUTED
40023684: 40 00 81 dd call 40043df8 <strtoul> <== NOT EXECUTED
40023688: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
4002368c: 10 bf ff cf b 400235c8 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
40023690: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
40023694: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
40023698: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
4002369c: 04 80 00 47 ble 400237b8 <rtems_shell_rfs_format+0x234> <== NOT EXECUTED
400236a0: 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);
400236a4: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400236a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400236ac: 40 00 81 d3 call 40043df8 <strtoul> <== NOT EXECUTED
400236b0: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400236b4: 10 bf ff c5 b 400235c8 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
400236b8: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
}
config.group_blocks = strtoul (argv[arg], 0, 0);
break;
case 'i':
arg++;
400236bc: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
400236c0: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
400236c4: 04 80 00 37 ble 400237a0 <rtems_shell_rfs_format+0x21c> <== NOT EXECUTED
400236c8: 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);
400236cc: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400236d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
400236d4: 40 00 81 c9 call 40043df8 <strtoul> <== NOT EXECUTED
400236d8: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400236dc: 10 bf ff bb b 400235c8 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
400236e0: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
400236e4: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
400236e8: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
400236ec: 04 80 00 21 ble 40023770 <rtems_shell_rfs_format+0x1ec> <== NOT EXECUTED
400236f0: 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);
400236f4: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400236f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400236fc: 40 00 81 bf call 40043df8 <strtoul> <== NOT EXECUTED
40023700: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
40023704: 10 bf ff b1 b 400235c8 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
40023708: 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;
4002370c: 10 bf ff af b 400235c8 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
40023710: 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]);
40023714: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
40023718: 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]);
4002371c: 40 00 71 e2 call 4003fea4 <printf> <== NOT EXECUTED
40023720: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
40023724: 81 c7 e0 08 ret <== NOT EXECUTED
40023728: 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));
4002372c: 40 00 5f 8f call 4003b568 <__errno> <== NOT EXECUTED
40023730: 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",
40023734: 40 00 7b 34 call 40042404 <strerror> <== NOT EXECUTED
40023738: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4002373c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40023740: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40023744: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
40023748: 40 00 71 d7 call 4003fea4 <printf> <== NOT EXECUTED
4002374c: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 4005e2a8 <rtems_rtc_shell_usage+0x18a0><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
40023750: 81 c7 e0 08 ret <== NOT EXECUTED
40023754: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
40023758: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
4002375c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
40023760: 40 00 72 69 call 40040104 <puts> <== NOT EXECUTED
40023764: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED
40023768: 81 c7 e0 08 ret <== NOT EXECUTED
4002376c: 81 e8 00 00 restore <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
40023770: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
40023774: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
40023778: 40 00 72 63 call 40040104 <puts> <== NOT EXECUTED
4002377c: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
40023780: 81 c7 e0 08 ret <== NOT EXECUTED
40023784: 81 e8 00 00 restore <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
40023788: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
4002378c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
40023790: 40 00 72 5d call 40040104 <puts> <== NOT EXECUTED
40023794: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
40023798: 81 c7 e0 08 ret <== NOT EXECUTED
4002379c: 81 e8 00 00 restore <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
400237a0: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
400237a4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
400237a8: 40 00 72 57 call 40040104 <puts> <== NOT EXECUTED
400237ac: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
400237b0: 81 c7 e0 08 ret <== NOT EXECUTED
400237b4: 81 e8 00 00 restore <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
400237b8: 11 10 01 78 sethi %hi(0x4005e000), %o0 <== NOT EXECUTED
return 1;
400237bc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
400237c0: 40 00 72 51 call 40040104 <puts> <== NOT EXECUTED
400237c4: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED
400237c8: 81 c7 e0 08 ret <== NOT EXECUTED
400237cc: 81 e8 00 00 restore <== NOT EXECUTED
40016590 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
40016590: 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 )
40016594: 80 a6 60 00 cmp %i1, 0
40016598: 12 80 00 04 bne 400165a8 <rtems_signal_send+0x18>
4001659c: 82 10 20 0a mov 0xa, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400165a0: 81 c7 e0 08 ret
400165a4: 91 e8 00 01 restore %g0, %g1, %o0
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
400165a8: 90 10 00 18 mov %i0, %o0
400165ac: 40 00 13 a5 call 4001b440 <_Thread_Get>
400165b0: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
400165b4: c2 07 bf fc ld [ %fp + -4 ], %g1
400165b8: 80 a0 60 00 cmp %g1, 0
400165bc: 12 80 00 20 bne 4001663c <rtems_signal_send+0xac>
400165c0: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
400165c4: fa 02 21 4c ld [ %o0 + 0x14c ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
400165c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400165cc: 80 a0 60 00 cmp %g1, 0
400165d0: 02 80 00 1e be 40016648 <rtems_signal_send+0xb8>
400165d4: 01 00 00 00 nop
if ( asr->is_enabled ) {
400165d8: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
400165dc: 80 a0 60 00 cmp %g1, 0
400165e0: 02 80 00 1e be 40016658 <rtems_signal_send+0xc8>
400165e4: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
400165e8: 7f ff e2 ea call 4000f190 <sparc_disable_interrupts>
400165ec: 01 00 00 00 nop
*signal_set |= signals;
400165f0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400165f4: b2 10 40 19 or %g1, %i1, %i1
400165f8: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
400165fc: 7f ff e2 e9 call 4000f1a0 <sparc_enable_interrupts>
40016600: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40016604: 03 10 00 f6 sethi %hi(0x4003d800), %g1
40016608: 82 10 61 90 or %g1, 0x190, %g1 ! 4003d990 <_Per_CPU_Information>
4001660c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40016610: 80 a0 a0 00 cmp %g2, 0
40016614: 02 80 00 06 be 4001662c <rtems_signal_send+0x9c>
40016618: 01 00 00 00 nop
4001661c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40016620: 80 a7 00 02 cmp %i4, %g2
40016624: 02 80 00 15 be 40016678 <rtems_signal_send+0xe8> <== ALWAYS TAKEN
40016628: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
4001662c: 40 00 13 79 call 4001b410 <_Thread_Enable_dispatch>
40016630: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
40016634: 10 bf ff db b 400165a0 <rtems_signal_send+0x10>
40016638: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4001663c: 82 10 20 04 mov 4, %g1
}
40016640: 81 c7 e0 08 ret
40016644: 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();
40016648: 40 00 13 72 call 4001b410 <_Thread_Enable_dispatch>
4001664c: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
40016650: 10 bf ff d4 b 400165a0 <rtems_signal_send+0x10>
40016654: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
40016658: 7f ff e2 ce call 4000f190 <sparc_disable_interrupts>
4001665c: 01 00 00 00 nop
*signal_set |= signals;
40016660: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40016664: b2 10 40 19 or %g1, %i1, %i1
40016668: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
4001666c: 7f ff e2 cd call 4000f1a0 <sparc_enable_interrupts>
40016670: 01 00 00 00 nop
40016674: 30 bf ff ee b,a 4001662c <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;
40016678: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
4001667c: 30 bf ff ec b,a 4001662c <rtems_signal_send+0x9c>
4000ef10 <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 )
{
4000ef10: 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 )
4000ef14: 92 10 00 1a mov %i2, %o1
4000ef18: 7f ff cd 9d call 4000258c <.umul>
4000ef1c: 90 06 60 08 add %i1, 8, %o0
+ key_table_size + data_size;
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
4000ef20: 7f ff d8 76 call 400050f8 <malloc>
4000ef24: 90 02 20 1c add %o0, 0x1c, %o0
4000ef28: 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 ) {
4000ef2c: 80 a2 60 00 cmp %o1, 0
4000ef30: 02 80 00 0b be 4000ef5c <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
4000ef34: 90 10 20 1a mov 0x1a, %o0
sc = rtems_sparse_disk_register(
4000ef38: 03 10 00 3b sethi %hi(0x4000ec00), %g1
4000ef3c: 82 10 62 18 or %g1, 0x218, %g1 ! 4000ee18 <rtems_sparse_disk_free>
4000ef40: 90 10 00 18 mov %i0, %o0
4000ef44: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000ef48: 94 10 00 19 mov %i1, %o2
4000ef4c: 96 10 00 1a mov %i2, %o3
4000ef50: 98 10 00 1b mov %i3, %o4
4000ef54: 7f ff ff b4 call 4000ee24 <rtems_sparse_disk_register>
4000ef58: 9a 10 00 1c mov %i4, %o5
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
4000ef5c: 81 c7 e0 08 ret
4000ef60: 91 e8 00 08 restore %g0, %o0, %o0
4000ef64: 40 00 ff e0 call 4004eee4 <__end+0x1fe54> <== NOT EXECUTED
4000ef68: 40 01 01 7c call 4004f558 <__end+0x204c8> <== NOT EXECUTED
4000ef6c: 40 01 01 74 call 4004f53c <__end+0x204ac> <== NOT EXECUTED
4000ef70: 40 01 01 60 call 4004f4f0 <__end+0x20460> <== NOT EXECUTED
4000ef74: 40 01 01 60 call 4004f4f4 <__end+0x20464> <== NOT EXECUTED
4000ef78: 40 01 01 60 call 4004f4f8 <__end+0x20468> <== NOT EXECUTED
4000ef7c: 40 01 01 60 call 4004f4fc <__end+0x2046c> <== NOT EXECUTED
4000ef80: 40 01 01 2c call 4004f430 <__end+0x203a0> <== NOT EXECUTED
4000ef84: 40 01 01 18 call 4004f3e4 <__end+0x20354> <== NOT EXECUTED
4000ef88: 40 01 01 18 call 4004f3e8 <__end+0x20358> <== NOT EXECUTED
4000ef8c: 40 01 01 18 call 4004f3ec <__end+0x2035c> <== NOT EXECUTED
4000ef90: 40 01 00 28 call 4004f030 <__end+0x1ffa0> <== NOT EXECUTED
4000ef94: 40 01 00 18 call 4004eff4 <__end+0x1ff64> <== NOT EXECUTED
4000ef98: 40 01 00 18 call 4004eff8 <__end+0x1ff68> <== NOT EXECUTED
4000ef9c: 40 01 00 f4 call 4004f36c <__end+0x202dc> <== NOT EXECUTED
4000efa0: 40 01 00 f4 call 4004f370 <__end+0x202e0> <== NOT EXECUTED
4000efa4: 40 01 00 f4 call 4004f374 <__end+0x202e4> <== NOT EXECUTED
4000efa8: 40 01 00 f4 call 4004f378 <__end+0x202e8> <== NOT EXECUTED
4000efac: 40 01 00 c0 call 4004f2ac <__end+0x2021c> <== NOT EXECUTED
4000efb0: 40 01 00 ac call 4004f260 <__end+0x201d0> <== NOT EXECUTED
4000efb4: 40 01 00 ac call 4004f264 <__end+0x201d4> <== NOT EXECUTED
4000efb8: 40 01 00 ac call 4004f268 <__end+0x201d8> <== NOT EXECUTED
4000efbc: 40 01 16 2c call 4005486c <__end+0x257dc> <== NOT EXECUTED
4000efc0: 40 01 16 2c call 40054870 <__end+0x257e0> <== NOT EXECUTED
4000efc4: 40 01 17 54 call 40054d14 <__end+0x25c84> <== NOT EXECUTED
4000efc8: 40 01 17 7c call 40054db8 <__end+0x25d28> <== NOT EXECUTED
4000efcc: 40 01 17 7c call 40054dbc <__end+0x25d2c> <== NOT EXECUTED
4000efd0: 40 01 17 7c call 40054dc0 <__end+0x25d30> <== NOT EXECUTED
4000efd4: 40 01 16 2c call 40054884 <__end+0x257f4> <== NOT EXECUTED
4000efd8: 40 01 17 44 call 40054ce8 <__end+0x25c58> <== NOT EXECUTED
4000efdc: 40 01 17 3c call 40054ccc <__end+0x25c3c> <== NOT EXECUTED
4000efe0: 40 01 17 84 call 40054df0 <__end+0x25d60> <== NOT EXECUTED
4000efe4: 40 01 16 2c call 40054894 <__end+0x25804> <== NOT EXECUTED
4000ee24 <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 )
{
4000ee24: 9d e3 bf a0 save %sp, -96, %sp
4000ee28: a2 10 00 18 mov %i0, %l1
4000ee2c: a0 10 00 19 mov %i1, %l0
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
4000ee30: 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 ) {
4000ee34: 80 a6 c0 1c cmp %i3, %i4
4000ee38: 08 80 00 04 bleu 4000ee48 <rtems_sparse_disk_register+0x24><== ALWAYS TAKEN
4000ee3c: f2 07 a0 5c ld [ %fp + 0x5c ], %i1
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
4000ee40: 81 c7 e0 08 ret <== NOT EXECUTED
4000ee44: 81 e8 00 00 restore <== NOT EXECUTED
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
4000ee48: 80 a4 20 00 cmp %l0, 0
4000ee4c: 02 80 00 2f be 4000ef08 <rtems_sparse_disk_register+0xe4> <== NEVER TAKEN
4000ee50: 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
4000ee54: 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 );
4000ee58: 90 10 00 10 mov %l0, %o0
4000ee5c: b0 04 a0 1c add %l2, 0x1c, %i0
4000ee60: 40 00 38 2e call 4001cf18 <memset>
4000ee64: 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;
4000ee68: 92 10 00 1a mov %i2, %o1
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
4000ee6c: 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;
4000ee70: 7f ff cd c7 call 4000258c <.umul>
4000ee74: 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 ),
4000ee78: 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;
4000ee7c: 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 ),
4000ee80: 92 10 00 1d mov %i5, %o1
4000ee84: 40 00 38 25 call 4001cf18 <memset>
4000ee88: 90 10 00 18 mov %i0, %o0
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
sc = rtems_semaphore_create(
4000ee8c: 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;
4000ee90: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
sc = rtems_semaphore_create(
4000ee94: 94 10 20 54 mov 0x54, %o2
4000ee98: 11 14 d4 10 sethi %hi(0x53504000), %o0
4000ee9c: 96 10 20 00 clr %o3
4000eea0: 90 12 21 52 or %o0, 0x152, %o0
4000eea4: 7f ff e8 ad call 40009158 <rtems_semaphore_create>
4000eea8: 98 10 00 10 mov %l0, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
4000eeac: b0 92 20 00 orcc %o0, 0, %i0
4000eeb0: 12 bf ff e4 bne 4000ee40 <rtems_sparse_disk_register+0x1c><== NEVER TAKEN
4000eeb4: 84 04 20 1c add %l0, 0x1c, %g2
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
4000eeb8: f6 24 20 04 st %i3, [ %l0 + 4 ]
sd->key_table = (rtems_sparse_disk_key *) data;
4000eebc: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000eec0: 82 10 20 00 clr %g1
4000eec4: 80 a6 e0 00 cmp %i3, 0
4000eec8: 02 80 00 08 be 4000eee8 <rtems_sparse_disk_register+0xc4> <== NEVER TAKEN
4000eecc: 84 00 80 12 add %g2, %l2, %g2
}
return sc;
}
rtems_status_code rtems_sparse_disk_register(
4000eed0: 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;
4000eed4: c4 20 e0 20 st %g2, [ %g3 + 0x20 ]
4000eed8: 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 ) {
4000eedc: 80 a4 80 01 cmp %l2, %g1
4000eee0: 12 bf ff fc bne 4000eed0 <rtems_sparse_disk_register+0xac>
4000eee4: 84 00 80 1a add %g2, %i2, %g2
sd->key_table[i].data = data;
}
sd->media_block_size = media_block_size;
4000eee8: f4 24 20 0c st %i2, [ %l0 + 0xc ]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
4000eeec: b2 10 00 1a mov %i2, %i1
4000eef0: 37 10 00 3a sethi %hi(0x4000e800), %i3
4000eef4: b4 10 00 1c mov %i4, %i2
4000eef8: b0 10 00 11 mov %l1, %i0
4000eefc: b6 16 e3 40 or %i3, 0x340, %i3
4000ef00: 40 00 0b 63 call 40011c8c <rtems_blkdev_create>
4000ef04: 99 e8 00 10 restore %g0, %l0, %o4
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
4000ef08: 81 c7 e0 08 ret <== NOT EXECUTED
4000ef0c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
40025190 <rtems_stack_checker_begin_extension>:
Thread_Control *the_thread
)
{
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
40025190: c2 02 20 08 ld [ %o0 + 8 ], %g1
40025194: 80 a0 60 00 cmp %g1, 0
40025198: 02 80 00 0c be 400251c8 <rtems_stack_checker_begin_extension+0x38><== NEVER TAKEN
4002519c: 05 10 01 a3 sethi %hi(0x40068c00), %g2
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
400251a0: c2 02 20 b8 ld [ %o0 + 0xb8 ], %g1
400251a4: c6 00 a2 dc ld [ %g2 + 0x2dc ], %g3
400251a8: 84 10 a2 dc or %g2, 0x2dc, %g2
400251ac: c6 20 60 08 st %g3, [ %g1 + 8 ]
400251b0: c6 00 a0 04 ld [ %g2 + 4 ], %g3
400251b4: c6 20 60 0c st %g3, [ %g1 + 0xc ]
400251b8: c6 00 a0 08 ld [ %g2 + 8 ], %g3
400251bc: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
400251c0: c4 00 a0 0c ld [ %g2 + 0xc ], %g2
400251c4: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
400251c8: 81 c3 e0 08 retl
400250dc <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
400250dc: 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 )
400250e0: 3b 10 01 9f sethi %hi(0x40067c00), %i5
400250e4: c2 07 60 f8 ld [ %i5 + 0xf8 ], %g1 ! 40067cf8 <Stack_check_Initialized>
400250e8: 80 a0 60 00 cmp %g1, 0
400250ec: 12 80 00 20 bne 4002516c <rtems_stack_checker_create_extension+0x90>
400250f0: 07 10 01 a3 sethi %hi(0x40068c00), %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 ];
400250f4: 09 3f bb 7c sethi %hi(0xfeedf000), %g4
400250f8: 82 10 e2 dc or %g3, 0x2dc, %g1
400250fc: 88 11 20 0d or %g4, 0xd, %g4
40025100: c8 20 e2 dc st %g4, [ %g3 + 0x2dc ]
40025104: 07 02 eb 43 sethi %hi(0xbad0c00), %g3
40025108: 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) {
4002510c: 05 10 01 a2 sethi %hi(0x40068800), %g2
40025110: d0 00 a1 b0 ld [ %g2 + 0x1b0 ], %o0 ! 400689b0 <_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 ];
40025114: c6 20 60 04 st %g3, [ %g1 + 4 ]
40025118: 07 37 ab 7c sethi %hi(0xdeadf000), %g3
4002511c: 86 10 e0 0d or %g3, 0xd, %g3 ! deadf00d <LEON_REG+0x5eadf00d>
40025120: c6 20 60 08 st %g3, [ %g1 + 8 ]
40025124: 07 18 03 43 sethi %hi(0x600d0c00), %g3
40025128: 86 10 e1 06 or %g3, 0x106, %g3 ! 600d0d06 <RAM_END+0x1fcd0d06>
4002512c: 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) {
40025130: 80 a2 20 00 cmp %o0, 0
40025134: 02 80 00 0c be 40025164 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40025138: 84 10 a1 b0 or %g2, 0x1b0, %g2
4002513c: d4 00 a0 04 ld [ %g2 + 4 ], %o2
40025140: 80 a2 a0 00 cmp %o2, 0
40025144: 02 80 00 08 be 40025164 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40025148: 03 10 01 a3 sethi %hi(0x40068c00), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
4002514c: 84 10 62 ec or %g1, 0x2ec, %g2 ! 40068eec <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40025150: 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;
40025154: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40025158: d4 20 62 ec st %o2, [ %g1 + 0x2ec ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
4002515c: 40 00 66 e1 call 4003ece0 <memset>
40025160: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
40025164: 82 10 20 01 mov 1, %g1
40025168: c2 27 60 f8 st %g1, [ %i5 + 0xf8 ]
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
4002516c: 80 a6 60 00 cmp %i1, 0
40025170: 02 80 00 06 be 40025188 <rtems_stack_checker_create_extension+0xac><== NEVER TAKEN
40025174: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
40025178: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
4002517c: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
40025180: 40 00 66 d8 call 4003ece0 <memset>
40025184: 92 10 20 a5 mov 0xa5, %o1
return true;
}
40025188: 81 c7 e0 08 ret
4002518c: 91 e8 20 01 restore %g0, 1, %o0
400252f0 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
400252f0: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
400252f4: 39 10 01 a2 sethi %hi(0x40068800), %i4
400252f8: b8 17 21 b0 or %i4, 0x1b0, %i4 ! 400689b0 <_Per_CPU_Information>
400252fc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40025300: d0 00 60 b8 ld [ %g1 + 0xb8 ], %o0
40025304: 80 a7 80 08 cmp %fp, %o0
40025308: 0a 80 00 06 bcs 40025320 <rtems_stack_checker_is_blown+0x30><== NEVER TAKEN
4002530c: ba 10 20 01 mov 1, %i5
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
40025310: c2 00 60 b4 ld [ %g1 + 0xb4 ], %g1
40025314: 82 02 00 01 add %o0, %g1, %g1
40025318: 80 a0 40 1e cmp %g1, %fp
4002531c: 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 ) {
40025320: 03 10 01 9f sethi %hi(0x40067c00), %g1
40025324: c2 00 60 f8 ld [ %g1 + 0xf8 ], %g1 ! 40067cf8 <Stack_check_Initialized>
40025328: 80 a0 60 00 cmp %g1, 0
4002532c: 02 80 00 12 be 40025374 <rtems_stack_checker_is_blown+0x84><== NEVER TAKEN
40025330: 82 10 20 00 clr %g1
pattern_ok = (!memcmp(
40025334: 90 02 20 08 add %o0, 8, %o0
40025338: 94 10 20 10 mov 0x10, %o2
4002533c: 13 10 01 a3 sethi %hi(0x40068c00), %o1
40025340: 40 00 65 af call 4003e9fc <memcmp>
40025344: 92 12 62 dc or %o1, 0x2dc, %o1 ! 40068edc <Stack_check_Pattern>
40025348: 80 a0 00 08 cmp %g0, %o0
4002534c: 82 60 3f ff subx %g0, -1, %g1
40025350: 92 10 00 01 mov %g1, %o1
40025354: 82 18 60 01 xor %g1, 1, %g1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
40025358: 80 88 60 ff btst 0xff, %g1
4002535c: 12 80 00 08 bne 4002537c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40025360: 80 8f 60 ff btst 0xff, %i5
40025364: 12 80 00 06 bne 4002537c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40025368: b0 10 20 00 clr %i0
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
4002536c: 81 c7 e0 08 ret
40025370: 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;
40025374: 10 bf ff f9 b 40025358 <rtems_stack_checker_is_blown+0x68><== NOT EXECUTED
40025378: 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 );
4002537c: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
40025380: 7f ff ff 94 call 400251d0 <Stack_check_report_blown_task> <== NOT EXECUTED
40025384: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
400253ec <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
400253ec: 13 10 00 9e sethi %hi(0x40027800), %o1 <== NOT EXECUTED
400253f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
400253f4: 92 12 63 44 or %o1, 0x344, %o1 <== NOT EXECUTED
400253f8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400253fc: 7f ff ff e4 call 4002538c <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
40025400: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4002538c <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
4002538c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( !print )
40025390: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40025394: 02 80 00 14 be 400253e4 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
40025398: 39 10 01 9f sethi %hi(0x40067c00), %i4 <== NOT EXECUTED
return;
print_context = context;
print_handler = print;
4002539c: 3b 10 01 9f sethi %hi(0x40067c00), %i5 <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
400253a0: f0 27 20 fc st %i0, [ %i4 + 0xfc ] <== NOT EXECUTED
print_handler = print;
400253a4: f2 27 61 00 st %i1, [ %i5 + 0x100 ] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
400253a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400253ac: 13 10 01 7b sethi %hi(0x4005ec00), %o1 <== NOT EXECUTED
400253b0: 9f c6 40 00 call %i1 <== NOT EXECUTED
400253b4: 92 12 60 28 or %o1, 0x28, %o1 ! 4005ec28 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8><== NOT EXECUTED
(*print)( context,
400253b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400253bc: 13 10 01 7b sethi %hi(0x4005ec00), %o1 <== NOT EXECUTED
400253c0: 9f c6 40 00 call %i1 <== NOT EXECUTED
400253c4: 92 12 60 40 or %o1, 0x40, %o1 ! 4005ec40 <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 );
400253c8: 11 10 00 93 sethi %hi(0x40024c00), %o0 <== NOT EXECUTED
400253cc: 40 00 12 b3 call 40029e98 <rtems_iterate_over_all_threads><== NOT EXECUTED
400253d0: 90 12 23 5c or %o0, 0x35c, %o0 ! 40024f5c <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);
400253d4: 7f ff fe e2 call 40024f5c <Stack_check_Dump_threads_usage><== NOT EXECUTED
400253d8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
#endif
print_context = NULL;
400253dc: c0 27 20 fc clr [ %i4 + 0xfc ] <== NOT EXECUTED
print_handler = NULL;
400253e0: c0 27 61 00 clr [ %i5 + 0x100 ] <== NOT EXECUTED
400253e4: 81 c7 e0 08 ret <== NOT EXECUTED
400253e8: 81 e8 00 00 restore <== NOT EXECUTED
40025280 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
40025280: 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);
40025284: 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,
40025288: 13 10 01 a3 sethi %hi(0x40068c00), %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);
4002528c: 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,
40025290: 94 10 20 10 mov 0x10, %o2
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40025294: 80 a7 80 01 cmp %fp, %g1
40025298: 0a 80 00 07 bcs 400252b4 <rtems_stack_checker_switch_extension+0x34><== NEVER TAKEN
4002529c: 92 12 62 dc or %o1, 0x2dc, %o1
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
400252a0: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
400252a4: 82 00 40 02 add %g1, %g2, %g1
400252a8: 80 a7 80 01 cmp %fp, %g1
400252ac: 08 80 00 0a bleu 400252d4 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
400252b0: 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,
400252b4: 40 00 65 d2 call 4003e9fc <memcmp> <== NOT EXECUTED
400252b8: 01 00 00 00 nop <== NOT EXECUTED
400252bc: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
400252c0: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
400252c4: 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 );
400252c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400252cc: 7f ff ff c1 call 400251d0 <Stack_check_report_blown_task> <== NOT EXECUTED
400252d0: 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,
400252d4: 40 00 65 ca call 4003e9fc <memcmp>
400252d8: 01 00 00 00 nop
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
400252dc: 80 a2 20 00 cmp %o0, 0
400252e0: 12 bf ff fa bne 400252c8 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
400252e4: 92 10 20 00 clr %o1
400252e8: 81 c7 e0 08 ret
400252ec: 81 e8 00 00 restore
4000d8ec <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4000d8ec: 9d e3 bf 98 save %sp, -104, %sp
double result;
char *end;
if ( !n )
4000d8f0: 80 a6 60 00 cmp %i1, 0
4000d8f4: 02 80 00 1b be 4000d960 <rtems_string_to_double+0x74>
4000d8f8: b6 10 20 09 mov 9, %i3
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d8fc: 40 00 0c 5d call 40010a70 <__errno>
4000d900: 01 00 00 00 nop
4000d904: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d908: c0 26 40 00 clr [ %i1 ]
4000d90c: c0 26 60 04 clr [ %i1 + 4 ]
result = strtod( s, &end );
4000d910: 90 10 00 18 mov %i0, %o0
4000d914: 40 00 17 b8 call 400137f4 <strtod>
4000d918: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
*endptr = end;
4000d91c: c2 07 bf fc ld [ %fp + -4 ], %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4000d920: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000d924: 80 a6 a0 00 cmp %i2, 0
4000d928: 02 80 00 03 be 4000d934 <rtems_string_to_double+0x48>
4000d92c: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000d930: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000d934: 80 a6 00 01 cmp %i0, %g1
4000d938: 02 80 00 0a be 4000d960 <rtems_string_to_double+0x74>
4000d93c: b6 10 20 0b mov 0xb, %i3
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d940: 40 00 0c 4c call 40010a70 <__errno>
4000d944: 01 00 00 00 nop
4000d948: c2 02 00 00 ld [ %o0 ], %g1
4000d94c: 80 a0 60 22 cmp %g1, 0x22
4000d950: 02 80 00 06 be 4000d968 <rtems_string_to_double+0x7c>
4000d954: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000d958: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000d95c: b6 10 20 00 clr %i3
}
4000d960: 81 c7 e0 08 ret
4000d964: 91 e8 00 1b restore %g0, %i3, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000d968: 92 10 00 1d mov %i5, %o1
4000d96c: 94 10 20 00 clr %o2
4000d970: 96 10 20 00 clr %o3
4000d974: 40 00 41 f1 call 4001e138 <__eqdf2>
4000d978: b6 10 20 0a mov 0xa, %i3
4000d97c: 80 a2 20 00 cmp %o0, 0
4000d980: 02 bf ff f8 be 4000d960 <rtems_string_to_double+0x74> <== NEVER TAKEN
4000d984: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000d988: 92 10 00 1d mov %i5, %o1
4000d98c: 15 1f fb ff sethi %hi(0x7feffc00), %o2
4000d990: 96 10 3f ff mov -1, %o3
4000d994: 40 00 41 ff call 4001e190 <__gtdf2>
4000d998: 94 12 a3 ff or %o2, 0x3ff, %o2
4000d99c: 80 a2 20 00 cmp %o0, 0
4000d9a0: 14 bf ff f0 bg 4000d960 <rtems_string_to_double+0x74>
4000d9a4: 90 10 00 1c mov %i4, %o0
4000d9a8: 92 10 00 1d mov %i5, %o1
4000d9ac: 15 3f fb ff sethi %hi(0xffeffc00), %o2
4000d9b0: 96 10 3f ff mov -1, %o3
4000d9b4: 40 00 42 23 call 4001e240 <__ltdf2>
4000d9b8: 94 12 a3 ff or %o2, 0x3ff, %o2
4000d9bc: 80 a2 20 00 cmp %o0, 0
4000d9c0: 06 bf ff e8 bl 4000d960 <rtems_string_to_double+0x74> <== ALWAYS TAKEN
4000d9c4: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000d9c8: 10 bf ff e5 b 4000d95c <rtems_string_to_double+0x70> <== NOT EXECUTED
4000d9cc: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000d9d0 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4000d9d0: 9d e3 bf 98 save %sp, -104, %sp
float result;
char *end;
if ( !n )
4000d9d4: 80 a6 60 00 cmp %i1, 0
4000d9d8: 02 80 00 19 be 4000da3c <rtems_string_to_float+0x6c>
4000d9dc: ba 10 20 09 mov 9, %i5
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000d9e0: 40 00 0c 24 call 40010a70 <__errno>
4000d9e4: 01 00 00 00 nop
4000d9e8: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000d9ec: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
4000d9f0: 90 10 00 18 mov %i0, %o0
4000d9f4: 40 00 17 87 call 40013810 <strtof>
4000d9f8: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
*endptr = end;
4000d9fc: c2 07 bf fc ld [ %fp + -4 ], %g1
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
4000da00: 80 a6 a0 00 cmp %i2, 0
4000da04: 02 80 00 03 be 4000da10 <rtems_string_to_float+0x40>
4000da08: b8 10 00 08 mov %o0, %i4
*endptr = end;
4000da0c: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000da10: 80 a6 00 01 cmp %i0, %g1
4000da14: 02 80 00 0a be 4000da3c <rtems_string_to_float+0x6c>
4000da18: ba 10 20 0b mov 0xb, %i5
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000da1c: 40 00 0c 15 call 40010a70 <__errno>
4000da20: 01 00 00 00 nop
4000da24: c2 02 00 00 ld [ %o0 ], %g1
4000da28: 80 a0 60 22 cmp %g1, 0x22
4000da2c: 02 80 00 06 be 4000da44 <rtems_string_to_float+0x74>
4000da30: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000da34: f8 26 40 00 st %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000da38: ba 10 20 00 clr %i5
}
4000da3c: 81 c7 e0 08 ret
4000da40: 91 e8 00 1d restore %g0, %i5, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000da44: 92 10 20 00 clr %o1
4000da48: 40 00 3f 17 call 4001d6a4 <__eqsf2>
4000da4c: ba 10 20 0a mov 0xa, %i5
4000da50: 80 a2 20 00 cmp %o0, 0
4000da54: 02 bf ff fa be 4000da3c <rtems_string_to_float+0x6c> <== NEVER TAKEN
4000da58: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000da5c: 13 1f df ff sethi %hi(0x7f7ffc00), %o1
4000da60: 40 00 3f 26 call 4001d6f8 <__gtsf2>
4000da64: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7f7fffff <RAM_END+0x3f3fffff>
4000da68: 80 a2 20 00 cmp %o0, 0
4000da6c: 14 bf ff f4 bg 4000da3c <rtems_string_to_float+0x6c>
4000da70: 90 10 00 1c mov %i4, %o0
4000da74: 13 3f df ff sethi %hi(0xff7ffc00), %o1
4000da78: 40 00 3f 35 call 4001d74c <__ltsf2>
4000da7c: 92 12 63 ff or %o1, 0x3ff, %o1 ! ff7fffff <LEON_REG+0x7f7fffff>
4000da80: 80 a2 20 00 cmp %o0, 0
4000da84: 06 bf ff ee bl 4000da3c <rtems_string_to_float+0x6c> <== ALWAYS TAKEN
4000da88: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000da8c: 10 bf ff eb b 4000da38 <rtems_string_to_float+0x68> <== NOT EXECUTED
4000da90: f8 26 40 00 st %i4, [ %i1 ] <== NOT EXECUTED
4001f498 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4001f498: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4001f49c: 80 a6 60 00 cmp %i1, 0
4001f4a0: 02 80 00 1a be 4001f508 <rtems_string_to_int+0x70>
4001f4a4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4001f4a8: 40 00 70 30 call 4003b568 <__errno>
4001f4ac: 01 00 00 00 nop
4001f4b0: c0 22 00 00 clr [ %o0 ]
*n = 0;
4001f4b4: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4001f4b8: 90 10 00 18 mov %i0, %o0
4001f4bc: 92 07 bf fc add %fp, -4, %o1
4001f4c0: 40 00 91 00 call 400438c0 <strtol>
4001f4c4: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4001f4c8: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
4001f4cc: 80 a6 a0 00 cmp %i2, 0
4001f4d0: 02 80 00 03 be 4001f4dc <rtems_string_to_int+0x44>
4001f4d4: ba 10 00 08 mov %o0, %i5
*endptr = end;
4001f4d8: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4001f4dc: 80 a6 00 02 cmp %i0, %g2
4001f4e0: 02 80 00 0a be 4001f508 <rtems_string_to_int+0x70>
4001f4e4: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001f4e8: 40 00 70 20 call 4003b568 <__errno>
4001f4ec: 01 00 00 00 nop
4001f4f0: c2 02 00 00 ld [ %o0 ], %g1
4001f4f4: 80 a0 60 22 cmp %g1, 0x22
4001f4f8: 02 80 00 06 be 4001f510 <rtems_string_to_int+0x78>
4001f4fc: 03 20 00 00 sethi %hi(0x80000000), %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4001f500: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4001f504: 82 10 20 00 clr %g1
}
4001f508: 81 c7 e0 08 ret
4001f50c: 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 )))
4001f510: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001f514: 80 a0 60 00 cmp %g1, 0
4001f518: 02 bf ff fc be 4001f508 <rtems_string_to_int+0x70>
4001f51c: 82 10 20 0a mov 0xa, %g1
4001f520: 80 a7 60 00 cmp %i5, 0
4001f524: 02 bf ff f9 be 4001f508 <rtems_string_to_int+0x70> <== NEVER TAKEN
4001f528: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001f52c: 80 a7 40 02 cmp %i5, %g2
4001f530: 02 bf ff f6 be 4001f508 <rtems_string_to_int+0x70> <== ALWAYS TAKEN
4001f534: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4001f538: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4001f53c: 10 bf ff f3 b 4001f508 <rtems_string_to_int+0x70> <== NOT EXECUTED
4001f540: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000dc18 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4000dc18: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4000dc1c: 80 a6 60 00 cmp %i1, 0
4000dc20: 02 80 00 1a be 4000dc88 <rtems_string_to_long+0x70>
4000dc24: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000dc28: 40 00 0b 92 call 40010a70 <__errno>
4000dc2c: 01 00 00 00 nop
4000dc30: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000dc34: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000dc38: 90 10 00 18 mov %i0, %o0
4000dc3c: 92 07 bf fc add %fp, -4, %o1
4000dc40: 40 00 17 95 call 40013a94 <strtol>
4000dc44: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000dc48: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
4000dc4c: 80 a6 a0 00 cmp %i2, 0
4000dc50: 02 80 00 03 be 4000dc5c <rtems_string_to_long+0x44>
4000dc54: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000dc58: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000dc5c: 80 a6 00 02 cmp %i0, %g2
4000dc60: 02 80 00 0a be 4000dc88 <rtems_string_to_long+0x70>
4000dc64: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000dc68: 40 00 0b 82 call 40010a70 <__errno>
4000dc6c: 01 00 00 00 nop
4000dc70: c2 02 00 00 ld [ %o0 ], %g1
4000dc74: 80 a0 60 22 cmp %g1, 0x22
4000dc78: 02 80 00 06 be 4000dc90 <rtems_string_to_long+0x78>
4000dc7c: 03 20 00 00 sethi %hi(0x80000000), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000dc80: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000dc84: 82 10 20 00 clr %g1
}
4000dc88: 81 c7 e0 08 ret
4000dc8c: 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 )))
4000dc90: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000dc94: 80 a0 60 00 cmp %g1, 0
4000dc98: 02 bf ff fc be 4000dc88 <rtems_string_to_long+0x70>
4000dc9c: 82 10 20 0a mov 0xa, %g1
4000dca0: 80 a7 60 00 cmp %i5, 0
4000dca4: 02 bf ff f9 be 4000dc88 <rtems_string_to_long+0x70> <== NEVER TAKEN
4000dca8: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000dcac: 80 a7 40 02 cmp %i5, %g2
4000dcb0: 02 bf ff f6 be 4000dc88 <rtems_string_to_long+0x70> <== ALWAYS TAKEN
4000dcb4: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000dcb8: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000dcbc: 10 bf ff f3 b 4000dc88 <rtems_string_to_long+0x70> <== NOT EXECUTED
4000dcc0: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000db40 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4000db40: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
4000db44: 80 a6 60 00 cmp %i1, 0
4000db48: 02 80 00 1c be 4000dbb8 <rtems_string_to_long_long+0x78>
4000db4c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000db50: 40 00 0b c8 call 40010a70 <__errno>
4000db54: 01 00 00 00 nop
4000db58: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000db5c: c0 26 40 00 clr [ %i1 ]
4000db60: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
4000db64: 90 10 00 18 mov %i0, %o0
4000db68: 92 07 bf fc add %fp, -4, %o1
4000db6c: 40 00 17 d3 call 40013ab8 <strtoll>
4000db70: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000db74: c4 07 bf fc ld [ %fp + -4 ], %g2
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4000db78: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000db7c: 80 a6 a0 00 cmp %i2, 0
4000db80: 02 80 00 03 be 4000db8c <rtems_string_to_long_long+0x4c>
4000db84: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000db88: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000db8c: 80 a6 00 02 cmp %i0, %g2
4000db90: 02 80 00 0a be 4000dbb8 <rtems_string_to_long_long+0x78>
4000db94: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000db98: 40 00 0b b6 call 40010a70 <__errno>
4000db9c: 01 00 00 00 nop
4000dba0: c2 02 00 00 ld [ %o0 ], %g1
4000dba4: 80 a0 60 22 cmp %g1, 0x22
4000dba8: 02 80 00 06 be 4000dbc0 <rtems_string_to_long_long+0x80>
4000dbac: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000dbb0: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000dbb4: 82 10 20 00 clr %g1
}
4000dbb8: 81 c7 e0 08 ret
4000dbbc: 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 )))
4000dbc0: 07 3f ff ff sethi %hi(0xfffffc00), %g3
4000dbc4: 84 10 a3 ff or %g2, 0x3ff, %g2
4000dbc8: 86 10 e3 ff or %g3, 0x3ff, %g3
4000dbcc: 84 1f 00 02 xor %i4, %g2, %g2
4000dbd0: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000dbd4: 80 90 80 03 orcc %g2, %g3, %g0
4000dbd8: 12 80 00 04 bne 4000dbe8 <rtems_string_to_long_long+0xa8>
4000dbdc: 80 97 00 1d orcc %i4, %i5, %g0
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4000dbe0: 10 bf ff f6 b 4000dbb8 <rtems_string_to_long_long+0x78>
4000dbe4: 82 10 20 0a mov 0xa, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000dbe8: 02 bf ff f4 be 4000dbb8 <rtems_string_to_long_long+0x78> <== NEVER TAKEN
4000dbec: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000dbf0: 03 20 00 00 sethi %hi(0x80000000), %g1
4000dbf4: 80 a7 00 01 cmp %i4, %g1
4000dbf8: 32 bf ff ef bne,a 4000dbb4 <rtems_string_to_long_long+0x74><== NEVER TAKEN
4000dbfc: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000dc00: 80 a7 60 00 cmp %i5, 0
4000dc04: 22 bf ff ed be,a 4000dbb8 <rtems_string_to_long_long+0x78><== ALWAYS TAKEN
4000dc08: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
4000dc0c: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000dc10: 10 bf ff ea b 4000dbb8 <rtems_string_to_long_long+0x78> <== NOT EXECUTED
4000dc14: 82 10 20 00 clr %g1 <== NOT EXECUTED
4001f554 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4001f554: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4001f558: 80 a6 60 00 cmp %i1, 0
4001f55c: 02 80 00 1b be 4001f5c8 <rtems_string_to_unsigned_char+0x74>
4001f560: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4001f564: 40 00 70 01 call 4003b568 <__errno>
4001f568: 01 00 00 00 nop
4001f56c: c0 22 00 00 clr [ %o0 ]
*n = 0;
4001f570: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
4001f574: 90 10 00 18 mov %i0, %o0
4001f578: 92 07 bf fc add %fp, -4, %o1
4001f57c: 40 00 92 1f call 40043df8 <strtoul>
4001f580: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4001f584: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
4001f588: 80 a6 a0 00 cmp %i2, 0
4001f58c: 02 80 00 03 be 4001f598 <rtems_string_to_unsigned_char+0x44>
4001f590: ba 10 00 08 mov %o0, %i5
*endptr = end;
4001f594: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4001f598: 80 a6 00 02 cmp %i0, %g2
4001f59c: 02 80 00 0b be 4001f5c8 <rtems_string_to_unsigned_char+0x74>
4001f5a0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001f5a4: 40 00 6f f1 call 4003b568 <__errno>
4001f5a8: 01 00 00 00 nop
4001f5ac: c2 02 00 00 ld [ %o0 ], %g1
4001f5b0: 80 a0 60 22 cmp %g1, 0x22
4001f5b4: 02 80 00 0e be 4001f5ec <rtems_string_to_unsigned_char+0x98>
4001f5b8: 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 ) {
4001f5bc: 18 80 00 05 bgu 4001f5d0 <rtems_string_to_unsigned_char+0x7c>
4001f5c0: 82 10 20 00 clr %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4001f5c4: fa 2e 40 00 stb %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
}
4001f5c8: 81 c7 e0 08 ret
4001f5cc: 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;
4001f5d0: 40 00 6f e6 call 4003b568 <__errno>
4001f5d4: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
4001f5d8: 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;
4001f5dc: 84 10 20 22 mov 0x22, %g2
4001f5e0: c4 22 00 00 st %g2, [ %o0 ]
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4001f5e4: 81 c7 e0 08 ret
4001f5e8: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
4001f5ec: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4001f5f0: 80 a0 bf fd cmp %g2, -3
4001f5f4: 18 bf ff f5 bgu 4001f5c8 <rtems_string_to_unsigned_char+0x74><== ALWAYS TAKEN
4001f5f8: 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 ) {
4001f5fc: 10 bf ff f0 b 4001f5bc <rtems_string_to_unsigned_char+0x68><== NOT EXECUTED
4001f600: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
4000dd84 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4000dd84: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000dd88: 80 a6 60 00 cmp %i1, 0
4000dd8c: 02 80 00 1a be 4000ddf4 <rtems_string_to_unsigned_int+0x70>
4000dd90: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000dd94: 40 00 0b 37 call 40010a70 <__errno>
4000dd98: 01 00 00 00 nop
4000dd9c: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000dda0: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000dda4: 90 10 00 18 mov %i0, %o0
4000dda8: 92 07 bf fc add %fp, -4, %o1
4000ddac: 40 00 18 88 call 40013fcc <strtoul>
4000ddb0: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000ddb4: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
4000ddb8: 80 a6 a0 00 cmp %i2, 0
4000ddbc: 02 80 00 03 be 4000ddc8 <rtems_string_to_unsigned_int+0x44>
4000ddc0: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000ddc4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000ddc8: 80 a6 00 02 cmp %i0, %g2
4000ddcc: 02 80 00 0a be 4000ddf4 <rtems_string_to_unsigned_int+0x70>
4000ddd0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ddd4: 40 00 0b 27 call 40010a70 <__errno>
4000ddd8: 01 00 00 00 nop
4000dddc: c2 02 00 00 ld [ %o0 ], %g1
4000dde0: 80 a0 60 22 cmp %g1, 0x22
4000dde4: 02 80 00 06 be 4000ddfc <rtems_string_to_unsigned_int+0x78>
4000dde8: 84 07 7f ff add %i5, -1, %g2
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000ddec: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000ddf0: 82 10 20 00 clr %g1
}
4000ddf4: 81 c7 e0 08 ret
4000ddf8: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ddfc: 80 a0 bf fd cmp %g2, -3
4000de00: 18 bf ff fd bgu 4000ddf4 <rtems_string_to_unsigned_int+0x70><== ALWAYS TAKEN
4000de04: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000de08: 10 bf ff fa b 4000ddf0 <rtems_string_to_unsigned_int+0x6c><== NOT EXECUTED
4000de0c: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
4000b78c <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4000b78c: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000b790: 80 a6 60 00 cmp %i1, 0
4000b794: 02 80 00 1a be 4000b7fc <rtems_string_to_unsigned_long+0x70>
4000b798: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000b79c: 40 00 bf 73 call 4003b568 <__errno>
4000b7a0: 01 00 00 00 nop
4000b7a4: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000b7a8: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000b7ac: 90 10 00 18 mov %i0, %o0
4000b7b0: 92 07 bf fc add %fp, -4, %o1
4000b7b4: 40 00 e1 91 call 40043df8 <strtoul>
4000b7b8: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000b7bc: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
4000b7c0: 80 a6 a0 00 cmp %i2, 0
4000b7c4: 02 80 00 03 be 4000b7d0 <rtems_string_to_unsigned_long+0x44>
4000b7c8: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000b7cc: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000b7d0: 80 a6 00 02 cmp %i0, %g2
4000b7d4: 02 80 00 0a be 4000b7fc <rtems_string_to_unsigned_long+0x70>
4000b7d8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000b7dc: 40 00 bf 63 call 4003b568 <__errno>
4000b7e0: 01 00 00 00 nop
4000b7e4: c2 02 00 00 ld [ %o0 ], %g1
4000b7e8: 80 a0 60 22 cmp %g1, 0x22
4000b7ec: 02 80 00 06 be 4000b804 <rtems_string_to_unsigned_long+0x78>
4000b7f0: 84 07 7f ff add %i5, -1, %g2
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000b7f4: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000b7f8: 82 10 20 00 clr %g1
}
4000b7fc: 81 c7 e0 08 ret
4000b800: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000b804: 80 a0 bf fd cmp %g2, -3
4000b808: 18 bf ff fd bgu 4000b7fc <rtems_string_to_unsigned_long+0x70><== ALWAYS TAKEN
4000b80c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000b810: 10 bf ff fa b 4000b7f8 <rtems_string_to_unsigned_long+0x6c><== NOT EXECUTED
4000b814: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
4000de10 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4000de10: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
4000de14: 80 a6 60 00 cmp %i1, 0
4000de18: 02 80 00 1c be 4000de88 <rtems_string_to_unsigned_long_long+0x78>
4000de1c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000de20: 40 00 0b 14 call 40010a70 <__errno>
4000de24: 01 00 00 00 nop
4000de28: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000de2c: c0 26 40 00 clr [ %i1 ]
4000de30: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
4000de34: 90 10 00 18 mov %i0, %o0
4000de38: 92 07 bf fc add %fp, -4, %o1
4000de3c: 40 00 18 6d call 40013ff0 <strtoull>
4000de40: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000de44: c4 07 bf fc ld [ %fp + -4 ], %g2
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4000de48: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000de4c: 80 a6 a0 00 cmp %i2, 0
4000de50: 02 80 00 03 be 4000de5c <rtems_string_to_unsigned_long_long+0x4c>
4000de54: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000de58: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000de5c: 80 a6 00 02 cmp %i0, %g2
4000de60: 02 80 00 0a be 4000de88 <rtems_string_to_unsigned_long_long+0x78>
4000de64: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000de68: 40 00 0b 02 call 40010a70 <__errno>
4000de6c: 01 00 00 00 nop
4000de70: c2 02 00 00 ld [ %o0 ], %g1
4000de74: 80 a0 60 22 cmp %g1, 0x22
4000de78: 02 80 00 06 be 4000de90 <rtems_string_to_unsigned_long_long+0x80>
4000de7c: 86 87 7f ff addcc %i5, -1, %g3
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000de80: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000de84: 82 10 20 00 clr %g1
}
4000de88: 81 c7 e0 08 ret
4000de8c: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4000de90: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000de94: 80 a0 bf ff cmp %g2, -1
4000de98: 12 bf ff fa bne 4000de80 <rtems_string_to_unsigned_long_long+0x70><== NEVER TAKEN
4000de9c: 80 a0 ff fd cmp %g3, -3
4000dea0: 18 bf ff fa bgu 4000de88 <rtems_string_to_unsigned_long_long+0x78><== ALWAYS TAKEN
4000dea4: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000dea8: 10 bf ff f7 b 4000de84 <rtems_string_to_unsigned_long_long+0x74><== NOT EXECUTED
4000deac: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
40002a40 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
40002a40: 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 =
40002a44: 94 10 20 18 mov 0x18, %o2
40002a48: 92 10 00 18 mov %i0, %o1
40002a4c: 40 00 08 18 call 40004aac <rtems_filesystem_eval_path_start>
40002a50: 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(
40002a54: 92 07 be 78 add %fp, -392, %o1
40002a58: aa 10 00 08 mov %o0, %l5
40002a5c: 40 00 09 0d call 40004e90 <rtems_filesystem_location_copy_and_detach>
40002a60: 90 07 be 48 add %fp, -440, %o0
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
40002a64: 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;
40002a68: 84 10 20 60 mov 0x60, %g2
40002a6c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40002a70: c4 27 be 70 st %g2, [ %fp + -400 ]
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40002a74: 05 10 00 85 sethi %hi(0x40021400), %g2
40002a78: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 400216d0 <IMFS_ops>
40002a7c: 80 a0 40 02 cmp %g1, %g2
40002a80: 02 80 00 06 be 40002a98 <rtems_tarfs_load+0x58>
40002a84: 05 10 00 88 sethi %hi(0x40022000), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
40002a88: 84 10 a0 70 or %g2, 0x70, %g2 ! 40022070 <fifoIMFS_ops>
40002a8c: 80 a0 40 02 cmp %g1, %g2
40002a90: 12 80 00 78 bne 40002c70 <rtems_tarfs_load+0x230> <== ALWAYS TAKEN
40002a94: 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)
40002a98: 80 a6 a1 ff cmp %i2, 0x1ff
40002a9c: 08 80 00 4b bleu 40002bc8 <rtems_tarfs_load+0x188> <== NEVER TAKEN
40002aa0: 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);
40002aa4: 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))
40002aa8: 27 10 00 85 sethi %hi(0x40021400), %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);
40002aac: 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)
40002ab0: a2 10 22 00 mov 0x200, %l1
40002ab4: b8 10 22 00 mov 0x200, %i4
40002ab8: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
40002abc: a6 14 e3 58 or %l3, 0x358, %l3
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
40002ac0: 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);
40002ac4: 10 80 00 08 b 40002ae4 <rtems_tarfs_load+0xa4>
40002ac8: 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) {
40002acc: 02 80 00 46 be 40002be4 <rtems_tarfs_load+0x1a4>
40002ad0: 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)
40002ad4: b8 07 62 00 add %i5, 0x200, %i4
40002ad8: 80 a7 00 1a cmp %i4, %i2
40002adc: 18 80 00 3b bgu 40002bc8 <rtems_tarfs_load+0x188> <== NEVER TAKEN
40002ae0: a2 10 00 1c mov %i4, %l1
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
40002ae4: ba 06 40 1d add %i1, %i5, %i5
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
40002ae8: 92 10 00 13 mov %l3, %o1
40002aec: 90 07 61 01 add %i5, 0x101, %o0
40002af0: 40 00 46 2a call 40014398 <strncmp>
40002af4: 94 10 20 05 mov 5, %o2
40002af8: 80 a2 20 00 cmp %o0, 0
40002afc: 12 80 00 33 bne 40002bc8 <rtems_tarfs_load+0x188>
40002b00: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
40002b04: 92 10 00 1d mov %i5, %o1
40002b08: 40 00 46 7a call 400144f0 <strncpy>
40002b0c: 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);
40002b10: 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';
40002b14: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
40002b18: f6 0f 60 9c ldub [ %i5 + 0x9c ], %i3
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
40002b1c: 40 00 23 00 call 4000b71c <_rtems_octal2ulong>
40002b20: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40002b24: 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);
40002b28: a8 10 00 08 mov %o0, %l4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40002b2c: 40 00 22 fc call 4000b71c <_rtems_octal2ulong>
40002b30: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40002b34: 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);
40002b38: a4 10 00 08 mov %o0, %l2
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40002b3c: 40 00 22 f8 call 4000b71c <_rtems_octal2ulong>
40002b40: 90 07 60 94 add %i5, 0x94, %o0
40002b44: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
40002b48: 40 00 24 4f call 4000bc84 <_rtems_tar_header_checksum>
40002b4c: 90 10 00 1d mov %i5, %o0
40002b50: 80 a2 00 17 cmp %o0, %l7
40002b54: 12 80 00 1d bne 40002bc8 <rtems_tarfs_load+0x188> <== NEVER TAKEN
40002b58: 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) {
40002b5c: b6 0e e0 ff and %i3, 0xff, %i3
40002b60: 80 a6 e0 35 cmp %i3, 0x35
40002b64: 12 bf ff da bne 40002acc <rtems_tarfs_load+0x8c>
40002b68: 80 a6 e0 30 cmp %i3, 0x30
strcpy(full_filename, mountpoint);
40002b6c: 90 10 00 16 mov %l6, %o0
40002b70: 40 00 43 a6 call 40013a08 <stpcpy>
40002b74: 92 10 00 18 mov %i0, %o1
if (full_filename[strlen(full_filename)-1] != '/')
40002b78: c4 07 be 44 ld [ %fp + -444 ], %g2
40002b7c: 82 07 80 08 add %fp, %o0, %g1
40002b80: 82 00 40 02 add %g1, %g2, %g1
40002b84: c2 48 7f 00 ldsb [ %g1 + -256 ], %g1
40002b88: 80 a0 60 2f cmp %g1, 0x2f
40002b8c: 02 80 00 04 be 40002b9c <rtems_tarfs_load+0x15c> <== ALWAYS TAKEN
40002b90: 82 10 20 2f mov 0x2f, %g1
strcat(full_filename, "/");
40002b94: c0 2a 20 01 clrb [ %o0 + 1 ] <== NOT EXECUTED
40002b98: c2 2a 00 00 stb %g1, [ %o0 ] <== NOT EXECUTED
strcat(full_filename, filename);
40002b9c: 92 10 00 10 mov %l0, %o1
40002ba0: 40 00 43 b9 call 40013a84 <strcat>
40002ba4: 90 10 00 16 mov %l6, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
40002ba8: 90 10 00 16 mov %l6, %o0
40002bac: 40 00 04 14 call 40003bfc <mkdir>
40002bb0: 92 10 21 ff mov 0x1ff, %o1
40002bb4: 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)
40002bb8: b8 07 62 00 add %i5, 0x200, %i4
40002bbc: 80 a7 00 1a cmp %i4, %i2
40002bc0: 08 bf ff c9 bleu 40002ae4 <rtems_tarfs_load+0xa4> <== ALWAYS TAKEN
40002bc4: a2 10 00 1c mov %i4, %l1
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
40002bc8: 40 00 02 6e call 40003580 <rtems_filesystem_location_free>
40002bcc: 90 07 be 48 add %fp, -440, %o0
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
) {
rv = -1;
40002bd0: b0 10 20 00 clr %i0
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
rtems_filesystem_eval_path_cleanup( &ctx );
40002bd4: 40 00 07 f6 call 40004bac <rtems_filesystem_eval_path_cleanup>
40002bd8: 90 07 be 60 add %fp, -416, %o0
40002bdc: 81 c7 e0 08 ret
40002be0: 81 e8 00 00 restore
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
rtems_filesystem_location_free( currentloc );
40002be4: 40 00 02 67 call 40003580 <rtems_filesystem_location_free>
40002be8: 90 10 00 15 mov %l5, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
40002bec: 92 07 be 48 add %fp, -440, %o1
40002bf0: 40 00 01 96 call 40003248 <rtems_filesystem_location_clone>
40002bf4: 90 10 00 15 mov %l5, %o0
rtems_filesystem_eval_path_set_path(
40002bf8: 40 00 45 b6 call 400142d0 <strlen>
40002bfc: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
40002c00: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
40002c04: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
40002c08: 40 00 07 2c call 400048b8 <rtems_filesystem_eval_path_continue>
40002c0c: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40002c10: c2 05 60 10 ld [ %l5 + 0x10 ], %g1
40002c14: 05 10 00 87 sethi %hi(0x40021c00), %g2
40002c18: 84 10 a1 cc or %g2, 0x1cc, %g2 ! 40021dcc <rtems_filesystem_null_handlers>
40002c1c: 80 a0 40 02 cmp %g1, %g2
40002c20: 02 80 00 10 be 40002c60 <rtems_tarfs_load+0x220> <== NEVER TAKEN
40002c24: 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 =
40002c28: c2 05 60 14 ld [ %l5 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40002c2c: c2 00 60 08 ld [ %g1 + 8 ], %g1
40002c30: d6 07 be 6c ld [ %fp + -404 ], %o3
40002c34: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
40002c38: 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,
40002c3c: 98 0d 21 ff and %l4, 0x1ff, %o4
40002c40: 90 10 00 15 mov %l5, %o0
40002c44: 98 13 00 01 or %o4, %g1, %o4
40002c48: 40 00 24 c9 call 4000bf6c <IMFS_create_node_with_control>
40002c4c: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
40002c50: 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;
40002c54: c0 22 20 50 clr [ %o0 + 0x50 ]
40002c58: e4 22 20 54 st %l2, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
40002c5c: c2 22 20 58 st %g1, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
40002c60: ba 04 a1 ff add %l2, 0x1ff, %i5
offset += 512 * nblocks;
40002c64: ba 0f 7e 00 and %i5, -512, %i5
40002c68: 10 bf ff 9b b 40002ad4 <rtems_tarfs_load+0x94>
40002c6c: ba 07 40 11 add %i5, %l1, %i5
}
}
rtems_filesystem_location_free( &rootloc );
40002c70: 40 00 02 44 call 40003580 <rtems_filesystem_location_free>
40002c74: 90 07 be 48 add %fp, -440, %o0
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
) {
rv = -1;
40002c78: b0 10 3f ff mov -1, %i0
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
rtems_filesystem_eval_path_cleanup( &ctx );
40002c7c: 40 00 07 cc call 40004bac <rtems_filesystem_eval_path_cleanup>
40002c80: 90 07 be 60 add %fp, -416, %o0
40002c84: 81 c7 e0 08 ret
40002c88: 81 e8 00 00 restore
4001133c <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4001133c: 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 )
40011340: 80 a6 a0 00 cmp %i2, 0
40011344: 02 80 00 3b be 40011430 <rtems_task_mode+0xf4>
40011348: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4001134c: 21 10 00 6d sethi %hi(0x4001b400), %l0
40011350: a0 14 23 e0 or %l0, 0x3e0, %l0 ! 4001b7e0 <_Per_CPU_Information>
40011354: 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;
40011358: c4 0f 60 70 ldub [ %i5 + 0x70 ], %g2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4001135c: 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;
40011360: 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 ];
40011364: f8 07 61 4c ld [ %i5 + 0x14c ], %i4
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40011368: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4001136c: 80 a0 60 00 cmp %g1, 0
40011370: 12 80 00 40 bne 40011470 <rtems_task_mode+0x134>
40011374: 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;
40011378: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
4001137c: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
40011380: 7f ff eb e1 call 4000c304 <_CPU_ISR_Get_level>
40011384: 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;
40011388: a3 2c 60 0a sll %l1, 0xa, %l1
4001138c: 90 14 40 08 or %l1, %o0, %o0
old_mode |= _ISR_Get_level();
40011390: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
40011394: 80 8e 61 00 btst 0x100, %i1
40011398: 02 80 00 06 be 400113b0 <rtems_task_mode+0x74>
4001139c: 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;
400113a0: 83 36 20 08 srl %i0, 8, %g1
400113a4: 82 18 60 01 xor %g1, 1, %g1
400113a8: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
400113ac: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
400113b0: 80 8e 62 00 btst 0x200, %i1
400113b4: 12 80 00 21 bne 40011438 <rtems_task_mode+0xfc>
400113b8: 80 8e 22 00 btst 0x200, %i0
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
400113bc: 80 8e 60 0f btst 0xf, %i1
400113c0: 12 80 00 27 bne 4001145c <rtems_task_mode+0x120>
400113c4: 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 ) {
400113c8: 80 8e 64 00 btst 0x400, %i1
400113cc: 02 80 00 14 be 4001141c <rtems_task_mode+0xe0>
400113d0: 86 10 20 00 clr %g3
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
400113d4: 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;
400113d8: b1 36 20 0a srl %i0, 0xa, %i0
400113dc: b0 1e 20 01 xor %i0, 1, %i0
400113e0: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
400113e4: 80 a6 00 01 cmp %i0, %g1
400113e8: 22 80 00 0e be,a 40011420 <rtems_task_mode+0xe4>
400113ec: 03 10 00 6d sethi %hi(0x4001b400), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
400113f0: 7f ff c5 17 call 4000284c <sparc_disable_interrupts>
400113f4: f0 2f 20 08 stb %i0, [ %i4 + 8 ]
_signals = information->signals_pending;
400113f8: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
information->signals_pending = information->signals_posted;
400113fc: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
information->signals_posted = _signals;
40011400: 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;
40011404: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
40011408: 7f ff c5 15 call 4000285c <sparc_enable_interrupts>
4001140c: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
40011410: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40011414: 80 a0 00 01 cmp %g0, %g1
40011418: 86 40 20 00 addx %g0, 0, %g3
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
4001141c: 03 10 00 6d sethi %hi(0x4001b400), %g1
40011420: c4 00 63 d8 ld [ %g1 + 0x3d8 ], %g2 ! 4001b7d8 <_System_state_Current>
40011424: 80 a0 a0 03 cmp %g2, 3
40011428: 02 80 00 1f be 400114a4 <rtems_task_mode+0x168>
4001142c: 82 10 20 00 clr %g1
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
40011430: 81 c7 e0 08 ret
40011434: 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) ) {
40011438: 22 bf ff e1 be,a 400113bc <rtems_task_mode+0x80>
4001143c: c0 27 60 78 clr [ %i5 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
40011440: 03 10 00 6c sethi %hi(0x4001b000), %g1
40011444: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 4001b230 <_Thread_Ticks_per_timeslice>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40011448: 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;
4001144c: 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;
40011450: 82 10 20 01 mov 1, %g1
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40011454: 02 bf ff dd be 400113c8 <rtems_task_mode+0x8c>
40011458: 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 );
4001145c: 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 ) );
40011460: 7f ff c4 ff call 4000285c <sparc_enable_interrupts>
40011464: 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 ) {
40011468: 10 bf ff d9 b 400113cc <rtems_task_mode+0x90>
4001146c: 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;
40011470: 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;
40011474: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40011478: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
4001147c: 7f ff eb a2 call 4000c304 <_CPU_ISR_Get_level>
40011480: 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;
40011484: a3 2c 60 0a sll %l1, 0xa, %l1
40011488: 90 14 40 08 or %l1, %o0, %o0
old_mode |= _ISR_Get_level();
4001148c: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
40011490: 80 8e 61 00 btst 0x100, %i1
40011494: 02 bf ff c7 be 400113b0 <rtems_task_mode+0x74>
40011498: 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;
4001149c: 10 bf ff c2 b 400113a4 <rtems_task_mode+0x68>
400114a0: 83 36 20 08 srl %i0, 8, %g1
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
400114a4: 80 88 e0 ff btst 0xff, %g3
400114a8: 12 80 00 0a bne 400114d0 <rtems_task_mode+0x194>
400114ac: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
400114b0: c6 04 20 14 ld [ %l0 + 0x14 ], %g3
400114b4: 80 a0 80 03 cmp %g2, %g3
400114b8: 02 bf ff de be 40011430 <rtems_task_mode+0xf4>
400114bc: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
400114c0: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
400114c4: 80 a0 a0 00 cmp %g2, 0
400114c8: 02 bf ff da be 40011430 <rtems_task_mode+0xf4> <== NEVER TAKEN
400114cc: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
400114d0: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
400114d4: 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();
400114d8: 40 00 02 95 call 40011f2c <_Thread_Dispatch>
400114dc: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
400114e0: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
400114e4: 81 c7 e0 08 ret
400114e8: 91 e8 00 01 restore %g0, %g1, %o0
4000bd44 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
4000bd44: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
4000bd48: 80 a6 60 00 cmp %i1, 0
4000bd4c: 02 80 00 08 be 4000bd6c <rtems_task_set_priority+0x28>
4000bd50: 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 ) );
4000bd54: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000bd58: c4 08 61 9c ldub [ %g1 + 0x19c ], %g2 ! 4001a99c <rtems_maximum_priority>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
4000bd5c: 80 a6 40 02 cmp %i1, %g2
4000bd60: 18 80 00 1e bgu 4000bdd8 <rtems_task_set_priority+0x94>
4000bd64: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4000bd68: 80 a6 a0 00 cmp %i2, 0
4000bd6c: 02 80 00 1b be 4000bdd8 <rtems_task_set_priority+0x94>
4000bd70: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4000bd74: 90 10 00 18 mov %i0, %o0
4000bd78: 40 00 0a 22 call 4000e600 <_Thread_Get>
4000bd7c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000bd80: c2 07 bf fc ld [ %fp + -4 ], %g1
4000bd84: 80 a0 60 00 cmp %g1, 0
4000bd88: 12 80 00 16 bne 4000bde0 <rtems_task_set_priority+0x9c>
4000bd8c: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4000bd90: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4000bd94: 80 a6 60 00 cmp %i1, 0
4000bd98: 02 80 00 0d be 4000bdcc <rtems_task_set_priority+0x88>
4000bd9c: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
4000bda0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000bda4: 80 a0 60 00 cmp %g1, 0
4000bda8: 02 80 00 06 be 4000bdc0 <rtems_task_set_priority+0x7c>
4000bdac: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
4000bdb0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000bdb4: 80 a6 40 01 cmp %i1, %g1
4000bdb8: 1a 80 00 05 bcc 4000bdcc <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
4000bdbc: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
4000bdc0: 92 10 00 19 mov %i1, %o1
4000bdc4: 40 00 08 c9 call 4000e0e8 <_Thread_Change_priority>
4000bdc8: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
4000bdcc: 40 00 0a 01 call 4000e5d0 <_Thread_Enable_dispatch>
4000bdd0: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4000bdd4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000bdd8: 81 c7 e0 08 ret
4000bddc: 91 e8 00 01 restore %g0, %g1, %o0
4000bde0: 81 c7 e0 08 ret
4000bde4: 91 e8 00 01 restore %g0, %g1, %o0
40006148 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
40006148: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
4000614c: 80 a6 60 00 cmp %i1, 0
40006150: 02 80 00 1e be 400061c8 <rtems_task_variable_delete+0x80>
40006154: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
40006158: 90 10 00 18 mov %i0, %o0
4000615c: 40 00 08 b1 call 40008420 <_Thread_Get>
40006160: 92 07 bf fc add %fp, -4, %o1
switch (location) {
40006164: c2 07 bf fc ld [ %fp + -4 ], %g1
40006168: 80 a0 60 00 cmp %g1, 0
4000616c: 12 80 00 19 bne 400061d0 <rtems_task_variable_delete+0x88>
40006170: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
40006174: c2 02 21 58 ld [ %o0 + 0x158 ], %g1
while (tvp) {
40006178: 80 a0 60 00 cmp %g1, 0
4000617c: 02 80 00 10 be 400061bc <rtems_task_variable_delete+0x74>
40006180: 01 00 00 00 nop
if (tvp->ptr == ptr) {
40006184: c4 00 60 04 ld [ %g1 + 4 ], %g2
40006188: 80 a0 80 19 cmp %g2, %i1
4000618c: 32 80 00 09 bne,a 400061b0 <rtems_task_variable_delete+0x68>
40006190: d2 00 40 00 ld [ %g1 ], %o1
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
40006194: 10 80 00 18 b 400061f4 <rtems_task_variable_delete+0xac>
40006198: c4 00 40 00 ld [ %g1 ], %g2
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
4000619c: 80 a0 80 19 cmp %g2, %i1
400061a0: 22 80 00 0e be,a 400061d8 <rtems_task_variable_delete+0x90>
400061a4: c4 02 40 00 ld [ %o1 ], %g2
400061a8: 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;
400061ac: 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) {
400061b0: 80 a2 60 00 cmp %o1, 0
400061b4: 32 bf ff fa bne,a 4000619c <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
400061b8: c4 02 60 04 ld [ %o1 + 4 ], %g2
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
400061bc: 40 00 08 8d call 400083f0 <_Thread_Enable_dispatch>
400061c0: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
400061c4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400061c8: 81 c7 e0 08 ret
400061cc: 91 e8 00 01 restore %g0, %g1, %o0
400061d0: 81 c7 e0 08 ret
400061d4: 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;
400061d8: 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 );
400061dc: 40 00 00 2e call 40006294 <_RTEMS_Tasks_Invoke_task_variable_dtor>
400061e0: 01 00 00 00 nop
_Thread_Enable_dispatch();
400061e4: 40 00 08 83 call 400083f0 <_Thread_Enable_dispatch>
400061e8: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
400061ec: 10 bf ff f7 b 400061c8 <rtems_task_variable_delete+0x80>
400061f0: 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;
400061f4: 92 10 00 01 mov %g1, %o1
400061f8: 10 bf ff f9 b 400061dc <rtems_task_variable_delete+0x94>
400061fc: c4 22 21 58 st %g2, [ %o0 + 0x158 ]
40006200 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
40006200: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
40006204: 80 a6 60 00 cmp %i1, 0
40006208: 02 80 00 1b be 40006274 <rtems_task_variable_get+0x74>
4000620c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !result )
40006210: 80 a6 a0 00 cmp %i2, 0
40006214: 02 80 00 18 be 40006274 <rtems_task_variable_get+0x74>
40006218: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
4000621c: 40 00 08 81 call 40008420 <_Thread_Get>
40006220: 92 07 bf fc add %fp, -4, %o1
switch (location) {
40006224: c2 07 bf fc ld [ %fp + -4 ], %g1
40006228: 80 a0 60 00 cmp %g1, 0
4000622c: 12 80 00 14 bne 4000627c <rtems_task_variable_get+0x7c>
40006230: 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;
40006234: c2 02 21 58 ld [ %o0 + 0x158 ], %g1
while (tvp) {
40006238: 80 a0 60 00 cmp %g1, 0
4000623c: 32 80 00 07 bne,a 40006258 <rtems_task_variable_get+0x58>
40006240: c4 00 60 04 ld [ %g1 + 4 ], %g2
40006244: 30 80 00 10 b,a 40006284 <rtems_task_variable_get+0x84>
40006248: 80 a0 60 00 cmp %g1, 0
4000624c: 02 80 00 0e be 40006284 <rtems_task_variable_get+0x84> <== NEVER TAKEN
40006250: 01 00 00 00 nop
if (tvp->ptr == ptr) {
40006254: c4 00 60 04 ld [ %g1 + 4 ], %g2
40006258: 80 a0 80 19 cmp %g2, %i1
4000625c: 32 bf ff fb bne,a 40006248 <rtems_task_variable_get+0x48>
40006260: 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;
40006264: c2 00 60 0c ld [ %g1 + 0xc ], %g1
_Thread_Enable_dispatch();
40006268: 40 00 08 62 call 400083f0 <_Thread_Enable_dispatch>
4000626c: c2 26 80 00 st %g1, [ %i2 ]
return RTEMS_SUCCESSFUL;
40006270: 82 10 20 00 clr %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40006274: 81 c7 e0 08 ret
40006278: 91 e8 00 01 restore %g0, %g1, %o0
4000627c: 81 c7 e0 08 ret
40006280: 91 e8 00 01 restore %g0, %g1, %o0
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
40006284: 40 00 08 5b call 400083f0 <_Thread_Enable_dispatch>
40006288: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
4000628c: 10 bf ff fa b 40006274 <rtems_task_variable_get+0x74>
40006290: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
40005cf0 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40005cf0: 80 a2 20 09 cmp %o0, 9
40005cf4: 02 80 00 1c be 40005d64 <rtems_termios_baud_to_index+0x74>
40005cf8: 82 10 20 09 mov 9, %g1
40005cfc: 80 a2 20 09 cmp %o0, 9
40005d00: 08 80 00 1b bleu 40005d6c <rtems_termios_baud_to_index+0x7c>
40005d04: 80 a2 20 04 cmp %o0, 4
40005d08: 80 a2 20 0e cmp %o0, 0xe
40005d0c: 02 80 00 16 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005d10: 82 10 20 0e mov 0xe, %g1
40005d14: 80 a2 20 0e cmp %o0, 0xe
40005d18: 08 80 00 28 bleu 40005db8 <rtems_termios_baud_to_index+0xc8>
40005d1c: 80 a2 20 0b cmp %o0, 0xb
40005d20: 05 00 00 04 sethi %hi(0x1000), %g2
40005d24: 86 10 a0 02 or %g2, 2, %g3 ! 1002 <PROM_START+0x1002>
40005d28: 80 a2 00 03 cmp %o0, %g3
40005d2c: 02 80 00 0e be 40005d64 <rtems_termios_baud_to_index+0x74>
40005d30: 82 10 20 11 mov 0x11, %g1
40005d34: 80 a2 00 03 cmp %o0, %g3
40005d38: 08 80 00 3a bleu 40005e20 <rtems_termios_baud_to_index+0x130>
40005d3c: 80 a2 20 0f cmp %o0, 0xf
40005d40: 86 10 a0 03 or %g2, 3, %g3
40005d44: 80 a2 00 03 cmp %o0, %g3
40005d48: 02 80 00 07 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005d4c: 82 10 20 12 mov 0x12, %g1
40005d50: 84 10 a0 04 or %g2, 4, %g2
40005d54: 80 a2 00 02 cmp %o0, %g2
40005d58: 02 80 00 03 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005d5c: 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;
40005d60: 82 10 3f ff mov -1, %g1
}
return baud_index;
}
40005d64: 81 c3 e0 08 retl
40005d68: 90 10 00 01 mov %g1, %o0
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40005d6c: 02 bf ff fe be 40005d64 <rtems_termios_baud_to_index+0x74>
40005d70: 82 10 20 04 mov 4, %g1
40005d74: 80 a2 20 04 cmp %o0, 4
40005d78: 08 80 00 1d bleu 40005dec <rtems_termios_baud_to_index+0xfc>
40005d7c: 80 a2 20 01 cmp %o0, 1
40005d80: 80 a2 20 06 cmp %o0, 6
40005d84: 02 bf ff f8 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005d88: 82 10 20 06 mov 6, %g1
40005d8c: 80 a2 20 06 cmp %o0, 6
40005d90: 0a bf ff f5 bcs 40005d64 <rtems_termios_baud_to_index+0x74>
40005d94: 82 10 20 05 mov 5, %g1
40005d98: 80 a2 20 07 cmp %o0, 7
40005d9c: 02 bf ff f2 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005da0: 82 10 20 07 mov 7, %g1
40005da4: 80 a2 20 08 cmp %o0, 8
40005da8: 02 bf ff ef be 40005d64 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40005dac: 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;
40005db0: 10 bf ff ed b 40005d64 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40005db4: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40005db8: 02 bf ff eb be 40005d64 <rtems_termios_baud_to_index+0x74>
40005dbc: 82 10 20 0b mov 0xb, %g1
40005dc0: 80 a2 20 0b cmp %o0, 0xb
40005dc4: 0a bf ff e8 bcs 40005d64 <rtems_termios_baud_to_index+0x74>
40005dc8: 82 10 20 0a mov 0xa, %g1
40005dcc: 80 a2 20 0c cmp %o0, 0xc
40005dd0: 02 bf ff e5 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005dd4: 82 10 20 0c mov 0xc, %g1
40005dd8: 80 a2 20 0d cmp %o0, 0xd
40005ddc: 02 bf ff e2 be 40005d64 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40005de0: 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;
40005de4: 10 bf ff e0 b 40005d64 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40005de8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40005dec: 02 bf ff de be 40005d64 <rtems_termios_baud_to_index+0x74>
40005df0: 82 10 20 01 mov 1, %g1
40005df4: 80 a2 20 01 cmp %o0, 1
40005df8: 0a bf ff db bcs 40005d64 <rtems_termios_baud_to_index+0x74>
40005dfc: 82 10 20 00 clr %g1
40005e00: 80 a2 20 02 cmp %o0, 2
40005e04: 02 bf ff d8 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005e08: 82 10 20 02 mov 2, %g1
40005e0c: 80 a2 20 03 cmp %o0, 3
40005e10: 02 bf ff d5 be 40005d64 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40005e14: 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;
40005e18: 10 bf ff d3 b 40005d64 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40005e1c: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40005e20: 02 bf ff d1 be 40005d64 <rtems_termios_baud_to_index+0x74>
40005e24: 82 10 20 0f mov 0xf, %g1
40005e28: 84 10 a0 01 or %g2, 1, %g2
40005e2c: 80 a2 00 02 cmp %o0, %g2
40005e30: 12 bf ff cc bne 40005d60 <rtems_termios_baud_to_index+0x70><== NEVER TAKEN
40005e34: 82 10 20 10 mov 0x10, %g1
40005e38: 30 bf ff cb b,a 40005d64 <rtems_termios_baud_to_index+0x74>
40005074 <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
40005074: 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(
40005078: 39 10 00 7b sethi %hi(0x4001ec00), %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;
4000507c: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40005080: d0 07 21 70 ld [ %i4 + 0x170 ], %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;
40005084: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40005088: 92 10 20 00 clr %o1
4000508c: 40 00 08 c0 call 4000738c <rtems_semaphore_obtain>
40005090: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005094: 80 a2 20 00 cmp %o0, 0
40005098: 12 80 00 6e bne 40005250 <rtems_termios_close+0x1dc> <== NEVER TAKEN
4000509c: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
400050a0: c2 07 60 08 ld [ %i5 + 8 ], %g1
400050a4: 82 00 7f ff add %g1, -1, %g1
400050a8: 80 a0 60 00 cmp %g1, 0
400050ac: 12 80 00 39 bne 40005190 <rtems_termios_close+0x11c>
400050b0: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
400050b4: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
400050b8: 03 10 00 7a sethi %hi(0x4001e800), %g1
400050bc: 85 28 a0 05 sll %g2, 5, %g2
400050c0: 82 10 62 ac or %g1, 0x2ac, %g1
400050c4: 82 00 40 02 add %g1, %g2, %g1
400050c8: c2 00 60 04 ld [ %g1 + 4 ], %g1
400050cc: 80 a0 60 00 cmp %g1, 0
400050d0: 22 80 00 42 be,a 400051d8 <rtems_termios_close+0x164>
400050d4: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
400050d8: 9f c0 40 00 call %g1
400050dc: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
400050e0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
400050e4: 80 a0 60 02 cmp %g1, 2
400050e8: 22 80 00 4f be,a 40005224 <rtems_termios_close+0x1b0> <== NEVER TAKEN
400050ec: 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)
400050f0: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
400050f4: 80 a0 60 00 cmp %g1, 0
400050f8: 22 80 00 07 be,a 40005114 <rtems_termios_close+0xa0> <== ALWAYS TAKEN
400050fc: c2 07 40 00 ld [ %i5 ], %g1
(*tty->device.lastClose)(tty->major, tty->minor, arg);
40005100: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
40005104: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
40005108: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000510c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
40005110: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
40005114: 80 a0 60 00 cmp %g1, 0
40005118: 02 80 00 29 be 400051bc <rtems_termios_close+0x148>
4000511c: 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;
40005120: c4 20 60 04 st %g2, [ %g1 + 4 ]
40005124: c4 07 60 04 ld [ %i5 + 4 ], %g2
}
if (tty->back == NULL) {
40005128: 80 a0 a0 00 cmp %g2, 0
4000512c: 22 80 00 21 be,a 400051b0 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
40005130: 05 10 00 7b sethi %hi(0x4001ec00), %g2
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
40005134: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
40005138: 40 00 08 5e call 400072b0 <rtems_semaphore_delete>
4000513c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
40005140: 40 00 08 5c call 400072b0 <rtems_semaphore_delete>
40005144: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
40005148: 40 00 08 5a call 400072b0 <rtems_semaphore_delete>
4000514c: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
40005150: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005154: 80 a0 60 00 cmp %g1, 0
40005158: 02 80 00 13 be 400051a4 <rtems_termios_close+0x130>
4000515c: 01 00 00 00 nop
40005160: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005164: 80 a0 60 02 cmp %g1, 2
40005168: 02 80 00 0f be 400051a4 <rtems_termios_close+0x130>
4000516c: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
40005170: 7f ff f7 ae call 40003028 <free>
40005174: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
40005178: 7f ff f7 ac call 40003028 <free>
4000517c: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
40005180: 7f ff f7 aa call 40003028 <free>
40005184: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
40005188: 7f ff f7 a8 call 40003028 <free>
4000518c: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40005190: d0 07 21 70 ld [ %i4 + 0x170 ], %o0
40005194: 40 00 08 cd call 400074c8 <rtems_semaphore_release>
40005198: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
4000519c: 81 c7 e0 08 ret
400051a0: 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);
400051a4: 40 00 08 43 call 400072b0 <rtems_semaphore_delete>
400051a8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
400051ac: 30 bf ff f1 b,a 40005170 <rtems_termios_close+0xfc>
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
400051b0: c0 20 60 04 clr [ %g1 + 4 ]
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
400051b4: 10 bf ff e1 b 40005138 <rtems_termios_close+0xc4>
400051b8: c2 20 a1 78 st %g1, [ %g2 + 0x178 ]
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;
400051bc: 03 10 00 7b sethi %hi(0x4001ec00), %g1
if ( rtems_termios_ttyTail != NULL ) {
400051c0: 80 a0 a0 00 cmp %g2, 0
400051c4: 02 80 00 25 be 40005258 <rtems_termios_close+0x1e4> <== ALWAYS TAKEN
400051c8: c4 20 61 74 st %g2, [ %g1 + 0x174 ]
rtems_termios_ttyTail->forw = NULL;
400051cc: c0 20 80 00 clr [ %g2 ] <== NOT EXECUTED
400051d0: 10 bf ff d9 b 40005134 <rtems_termios_close+0xc0> <== NOT EXECUTED
400051d4: 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);
400051d8: 92 10 20 00 clr %o1
400051dc: 40 00 08 6c call 4000738c <rtems_semaphore_obtain>
400051e0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
400051e4: 80 a2 20 00 cmp %o0, 0
400051e8: 12 80 00 1a bne 40005250 <rtems_termios_close+0x1dc> <== NEVER TAKEN
400051ec: 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) {
400051f0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
400051f4: 80 a0 60 00 cmp %g1, 0
400051f8: 02 80 00 04 be 40005208 <rtems_termios_close+0x194>
400051fc: 01 00 00 00 nop
40005200: 7f ff fe 72 call 40004bc8 <drainOutput.part.0>
40005204: 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);
40005208: 40 00 08 b0 call 400074c8 <rtems_semaphore_release>
4000520c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40005210: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005214: 80 a0 60 02 cmp %g1, 2
40005218: 32 bf ff b7 bne,a 400050f4 <rtems_termios_close+0x80>
4000521c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
40005220: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
40005224: 40 00 07 21 call 40006ea8 <rtems_event_send>
40005228: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
4000522c: 80 a2 20 00 cmp %o0, 0
40005230: 12 80 00 08 bne 40005250 <rtems_termios_close+0x1dc> <== NEVER TAKEN
40005234: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
40005238: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
4000523c: 40 00 07 1b call 40006ea8 <rtems_event_send>
40005240: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
40005244: 80 a2 20 00 cmp %o0, 0
40005248: 22 bf ff ab be,a 400050f4 <rtems_termios_close+0x80> <== ALWAYS TAKEN
4000524c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
40005250: 40 00 0a 34 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40005254: 01 00 00 00 nop <== NOT EXECUTED
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
40005258: 03 10 00 7b sethi %hi(0x4001ec00), %g1
4000525c: 10 bf ff b7 b 40005138 <rtems_termios_close+0xc4>
40005260: c0 20 61 78 clr [ %g1 + 0x178 ] ! 4001ed78 <rtems_termios_ttyHead>
4000675c <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)
{
4000675c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40006760: c4 06 20 90 ld [ %i0 + 0x90 ], %g2
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40006764: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40006768: b2 00 80 19 add %g2, %i1, %i1
4000676c: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40006770: 80 a0 60 02 cmp %g1, 2
40006774: 02 80 00 10 be 400067b4 <rtems_termios_dequeue_characters+0x58>
40006778: 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 ) {
4000677c: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
40006780: 80 a0 60 05 cmp %g1, 5
40006784: 02 80 00 04 be 40006794 <rtems_termios_dequeue_characters+0x38>
40006788: 03 10 00 7a sethi %hi(0x4001e800), %g1
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
4000678c: 7f ff f8 73 call 40004958 <rtems_termios_refill_transmitter>
40006790: 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) {
40006794: c2 00 63 60 ld [ %g1 + 0x360 ], %g1
40006798: 80 a0 60 00 cmp %g1, 0
4000679c: 02 80 00 04 be 400067ac <rtems_termios_dequeue_characters+0x50><== NEVER TAKEN
400067a0: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
400067a4: 9f c0 40 00 call %g1
400067a8: 01 00 00 00 nop
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
400067ac: 81 c7 e0 08 ret
400067b0: 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);
400067b4: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
400067b8: 40 00 01 bc call 40006ea8 <rtems_event_send>
400067bc: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
400067c0: 80 a2 20 00 cmp %o0, 0
400067c4: 02 bf ff fa be 400067ac <rtems_termios_dequeue_characters+0x50><== ALWAYS TAKEN
400067c8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
400067cc: 40 00 04 d5 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
400063b4 <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)
{
400063b4: 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) {
400063b8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
400063bc: 37 10 00 7a sethi %hi(0x4001e800), %i3
400063c0: 83 28 60 05 sll %g1, 5, %g1
400063c4: b6 16 e2 ac or %i3, 0x2ac, %i3
400063c8: 82 06 c0 01 add %i3, %g1, %g1
400063cc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400063d0: 80 a0 60 00 cmp %g1, 0
400063d4: 02 80 00 23 be 40006460 <rtems_termios_enqueue_raw_characters+0xac>
400063d8: 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)
400063dc: 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--) {
400063e0: 80 a6 a0 00 cmp %i2, 0
400063e4: 12 80 00 08 bne 40006404 <rtems_termios_enqueue_raw_characters+0x50><== ALWAYS TAKEN
400063e8: 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 )) {
400063ec: 10 80 00 0d b 40006420 <rtems_termios_enqueue_raw_characters+0x6c><== NOT EXECUTED
400063f0: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1 <== NOT EXECUTED
400063f4: ba 07 60 01 inc %i5
400063f8: 83 28 60 05 sll %g1, 5, %g1
400063fc: 82 06 c0 01 add %i3, %g1, %g1
40006400: 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);
40006404: d0 4e 40 1d ldsb [ %i1 + %i5 ], %o0
40006408: 9f c0 40 00 call %g1
4000640c: 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--) {
40006410: 80 a7 40 18 cmp %i5, %i0
40006414: 32 bf ff f8 bne,a 400063f4 <rtems_termios_enqueue_raw_characters+0x40>
40006418: 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 )) {
4000641c: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
40006420: 80 a0 60 00 cmp %g1, 0
40006424: 12 80 00 0d bne 40006458 <rtems_termios_enqueue_raw_characters+0xa4><== NEVER TAKEN
40006428: 01 00 00 00 nop
4000642c: c2 07 20 dc ld [ %i4 + 0xdc ], %g1
40006430: 80 a0 60 00 cmp %g1, 0
40006434: 02 80 00 07 be 40006450 <rtems_termios_enqueue_raw_characters+0x9c>
40006438: b0 10 20 00 clr %i0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
4000643c: d2 07 20 e0 ld [ %i4 + 0xe0 ], %o1
40006440: 9f c0 40 00 call %g1
40006444: 90 07 20 30 add %i4, 0x30, %o0
tty->tty_rcvwakeup = 1;
40006448: 82 10 20 01 mov 1, %g1
4000644c: c2 27 20 e4 st %g1, [ %i4 + 0xe4 ]
40006450: 81 c7 e0 08 ret
40006454: 81 e8 00 00 restore
}
return 0;
40006458: 81 c7 e0 08 ret <== NOT EXECUTED
4000645c: 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)
40006460: b4 06 40 1a add %i1, %i2, %i2
40006464: a0 10 20 00 clr %l0
40006468: 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);
4000646c: 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);
40006470: a4 07 20 4a add %i4, 0x4a, %l2
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
40006474: 80 a6 40 1a cmp %i1, %i2
40006478: 22 80 00 28 be,a 40006518 <rtems_termios_enqueue_raw_characters+0x164>
4000647c: 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) {
40006480: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
40006484: 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) {
40006488: 80 88 62 00 btst 0x200, %g1
4000648c: 02 80 00 0b be 400064b8 <rtems_termios_enqueue_raw_characters+0x104>
40006490: 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]) {
40006494: c4 0f 20 4a ldub [ %i4 + 0x4a ], %g2
40006498: 83 2f 60 18 sll %i5, 0x18, %g1
4000649c: 83 38 60 18 sra %g1, 0x18, %g1
400064a0: 80 a0 40 02 cmp %g1, %g2
400064a4: 02 80 00 5c be 40006614 <rtems_termios_enqueue_raw_characters+0x260>
400064a8: 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]) {
400064ac: 80 a0 40 02 cmp %g1, %g2
400064b0: 02 80 00 61 be 40006634 <rtems_termios_enqueue_raw_characters+0x280><== NEVER TAKEN
400064b4: 01 00 00 00 nop
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
400064b8: 80 8c 20 ff btst 0xff, %l0
400064bc: 02 80 00 1d be 40006530 <rtems_termios_enqueue_raw_characters+0x17c><== ALWAYS TAKEN
400064c0: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
400064c4: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
400064c8: 82 08 60 30 and %g1, 0x30, %g1
400064cc: 80 a0 60 20 cmp %g1, 0x20
400064d0: 12 bf ff ea bne 40006478 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400064d4: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
400064d8: 7f ff ee f3 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
400064dc: 01 00 00 00 nop <== NOT EXECUTED
400064e0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400064e4: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400064e8: 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;
400064ec: 84 08 bf df and %g2, -33, %g2 <== NOT EXECUTED
400064f0: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400064f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400064f8: 12 80 00 57 bne 40006654 <rtems_termios_enqueue_raw_characters+0x2a0><== NOT EXECUTED
400064fc: 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);
40006500: 7f ff ee ed call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40006504: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
40006508: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
4000650c: 12 bf ff dd bne 40006480 <rtems_termios_enqueue_raw_characters+0xcc><== NOT EXECUTED
40006510: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
40006514: c2 07 20 78 ld [ %i4 + 0x78 ], %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
40006518: d0 07 20 68 ld [ %i4 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
4000651c: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
40006520: 40 00 03 ea call 400074c8 <rtems_semaphore_release>
40006524: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
return dropped;
40006528: 81 c7 e0 08 ret
4000652c: 81 e8 00 00 restore
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
40006530: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
40006534: d2 07 20 64 ld [ %i4 + 0x64 ], %o1
40006538: 40 00 49 7b call 40018b24 <.urem>
4000653c: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
40006540: 7f ff ee d9 call 400020a4 <sparc_disable_interrupts>
40006544: b6 10 00 08 mov %o0, %i3
40006548: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
4000654c: c2 07 20 5c ld [ %i4 + 0x5c ], %g1
40006550: d0 07 20 64 ld [ %i4 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
40006554: 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)
40006558: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
4000655c: 40 00 49 72 call 40018b24 <.urem>
40006560: 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)
40006564: c2 07 20 c0 ld [ %i4 + 0xc0 ], %g1
40006568: 80 a2 00 01 cmp %o0, %g1
4000656c: 08 80 00 13 bleu 400065b8 <rtems_termios_enqueue_raw_characters+0x204><== ALWAYS TAKEN
40006570: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
40006574: 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) &&
40006578: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
4000657c: 12 80 00 0f bne 400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40006580: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
40006584: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
40006588: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
4000658c: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40006590: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
40006594: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
40006598: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
4000659c: 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))
400065a0: 02 80 00 35 be 40006674 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
400065a4: 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) ) {
400065a8: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
400065ac: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
400065b0: 02 80 00 40 be 400066b0 <rtems_termios_enqueue_raw_characters+0x2fc><== NOT EXECUTED
400065b4: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
400065b8: 7f ff ee bf call 400020b4 <sparc_enable_interrupts>
400065bc: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
400065c0: c2 07 20 5c ld [ %i4 + 0x5c ], %g1
400065c4: 80 a0 40 1b cmp %g1, %i3
400065c8: 22 bf ff ab be,a 40006474 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
400065cc: b0 06 20 01 inc %i0 <== NOT EXECUTED
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
400065d0: c2 07 20 58 ld [ %i4 + 0x58 ], %g1
400065d4: 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 )) {
400065d8: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
400065dc: 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 )) {
400065e0: 80 a0 60 00 cmp %g1, 0
400065e4: 12 bf ff a5 bne 40006478 <rtems_termios_enqueue_raw_characters+0xc4><== NEVER TAKEN
400065e8: 80 a6 40 1a cmp %i1, %i2
400065ec: c2 07 20 dc ld [ %i4 + 0xdc ], %g1
400065f0: 80 a0 60 00 cmp %g1, 0
400065f4: 02 bf ff a1 be 40006478 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400065f8: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400065fc: d2 07 20 e0 ld [ %i4 + 0xe0 ], %o1 <== NOT EXECUTED
40006600: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006604: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
40006608: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000660c: 10 bf ff 9a b 40006474 <rtems_termios_enqueue_raw_characters+0xc0><== NOT EXECUTED
40006610: 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]) {
40006614: 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;
40006618: 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]) {
4000661c: 22 80 00 0b be,a 40006648 <rtems_termios_enqueue_raw_characters+0x294><== NEVER TAKEN
40006620: 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;
40006624: 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)
40006628: 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;
4000662c: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ]
40006630: 30 bf ff a5 b,a 400064c4 <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;
40006634: 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)
40006638: 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;
4000663c: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
40006640: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
40006644: 30 bf ff a0 b,a 400064c4 <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)
40006648: 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;
4000664c: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
40006650: 30 bf ff 9d b,a 400064c4 <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);
40006654: 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)(
40006658: d2 07 20 7c ld [ %i4 + 0x7c ], %o1 <== NOT EXECUTED
4000665c: c2 07 20 a4 ld [ %i4 + 0xa4 ], %g1 <== NOT EXECUTED
40006660: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
40006664: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40006668: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000666c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40006670: 30 bf ff a4 b,a 40006500 <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) ||
40006674: 12 80 00 06 bne 4000668c <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
40006678: 01 00 00 00 nop <== NOT EXECUTED
4000667c: c2 07 20 94 ld [ %i4 + 0x94 ], %g1 <== NOT EXECUTED
40006680: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006684: 12 bf ff cd bne 400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40006688: 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;
4000668c: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
40006690: c2 07 20 a4 ld [ %i4 + 0xa4 ], %g1 <== NOT EXECUTED
40006694: 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;
40006698: 84 10 a0 02 or %g2, 2, %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
4000669c: 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;
400066a0: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400066a4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400066a8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
400066ac: 30 bf ff c3 b,a 400065b8 <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;
400066b0: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
400066b4: 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;
400066b8: 84 10 a0 04 or %g2, 4, %g2 <== NOT EXECUTED
400066bc: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
400066c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400066c4: 02 bf ff bd be 400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
400066c8: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
400066cc: 9f c0 40 00 call %g1 <== NOT EXECUTED
400066d0: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
400066d4: 30 bf ff b9 b,a 400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40005284 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40005284: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005288: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
4000528c: 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;
40005290: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40005294: 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);
40005298: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
4000529c: 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;
400052a0: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400052a4: 40 00 08 3a call 4000738c <rtems_semaphore_obtain>
400052a8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
400052ac: b0 92 20 00 orcc %o0, 0, %i0
400052b0: 12 80 00 23 bne 4000533c <rtems_termios_ioctl+0xb8> <== NEVER TAKEN
400052b4: 01 00 00 00 nop
return sc;
}
switch (args->command) {
400052b8: c2 07 20 04 ld [ %i4 + 4 ], %g1
400052bc: 80 a0 60 05 cmp %g1, 5
400052c0: 22 80 00 1a be,a 40005328 <rtems_termios_ioctl+0xa4>
400052c4: c2 06 c0 00 ld [ %i3 ], %g1
400052c8: 18 80 00 1f bgu 40005344 <rtems_termios_ioctl+0xc0>
400052cc: 05 10 01 19 sethi %hi(0x40046400), %g2
400052d0: 80 a0 60 02 cmp %g1, 2
400052d4: 22 80 00 2f be,a 40005390 <rtems_termios_ioctl+0x10c>
400052d8: d2 07 20 08 ld [ %i4 + 8 ], %o1
400052dc: 18 80 00 bf bgu 400055d8 <rtems_termios_ioctl+0x354>
400052e0: 80 a0 60 03 cmp %g1, 3
400052e4: 80 a0 60 01 cmp %g1, 1
400052e8: 22 80 00 d0 be,a 40005628 <rtems_termios_ioctl+0x3a4> <== ALWAYS TAKEN
400052ec: d0 07 20 08 ld [ %i4 + 8 ], %o0
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
400052f0: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
400052f4: 03 10 00 7a sethi %hi(0x4001e800), %g1
400052f8: 85 28 a0 05 sll %g2, 5, %g2
400052fc: 82 10 62 ac or %g1, 0x2ac, %g1
40005300: 82 00 40 02 add %g1, %g2, %g1
40005304: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40005308: 80 a0 60 00 cmp %g1, 0
4000530c: 02 80 00 0a be 40005334 <rtems_termios_ioctl+0xb0>
40005310: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
40005314: 90 10 00 1d mov %i5, %o0
40005318: 9f c0 40 00 call %g1
4000531c: 92 10 00 1c mov %i4, %o1
40005320: 10 80 00 05 b 40005334 <rtems_termios_ioctl+0xb0>
40005324: b0 10 00 08 mov %o0, %i0
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
40005328: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
4000532c: c2 06 e0 04 ld [ %i3 + 4 ], %g1
40005330: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
40005334: 40 00 08 65 call 400074c8 <rtems_semaphore_release>
40005338: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
4000533c: 81 c7 e0 08 ret
40005340: 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) {
40005344: 84 10 a2 7f or %g2, 0x27f, %g2
40005348: 80 a0 40 02 cmp %g1, %g2
4000534c: 02 80 00 77 be 40005528 <rtems_termios_ioctl+0x2a4> <== NEVER TAKEN
40005350: 01 00 00 00 nop
40005354: 38 80 00 81 bgu,a 40005558 <rtems_termios_ioctl+0x2d4>
40005358: 05 10 01 1d sethi %hi(0x40047400), %g2
4000535c: 80 a0 60 06 cmp %g1, 6
40005360: 32 bf ff e5 bne,a 400052f4 <rtems_termios_ioctl+0x70>
40005364: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
40005368: c2 07 20 08 ld [ %i4 + 8 ], %g1
4000536c: 80 a0 60 01 cmp %g1, 1
40005370: 02 80 00 c3 be 4000567c <rtems_termios_ioctl+0x3f8>
40005374: 80 a0 60 02 cmp %g1, 2
40005378: 02 80 00 d1 be 400056bc <rtems_termios_ioctl+0x438>
4000537c: 80 a0 60 00 cmp %g1, 0
40005380: 02 80 00 d6 be 400056d8 <rtems_termios_ioctl+0x454>
40005384: 01 00 00 00 nop
case TCIOFLUSH:
flushOutput (tty);
flushInput (tty);
break;
default:
sc = RTEMS_INVALID_NAME;
40005388: 10 bf ff eb b 40005334 <rtems_termios_ioctl+0xb0>
4000538c: 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;
40005390: 94 10 20 24 mov 0x24, %o2
40005394: b8 07 60 30 add %i5, 0x30, %i4
40005398: 40 00 2b 3b call 40010084 <memcpy>
4000539c: 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) &&
400053a0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400053a4: 80 88 62 00 btst 0x200, %g1
400053a8: 02 80 00 19 be 4000540c <rtems_termios_ioctl+0x188>
400053ac: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
400053b0: 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) &&
400053b4: 80 88 64 00 btst 0x400, %g1
400053b8: 12 80 00 15 bne 4000540c <rtems_termios_ioctl+0x188>
400053bc: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
400053c0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400053c4: 82 08 7d ef and %g1, -529, %g1
400053c8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
400053cc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400053d0: 80 88 60 20 btst 0x20, %g1
400053d4: 02 80 00 0e be 4000540c <rtems_termios_ioctl+0x188> <== ALWAYS TAKEN
400053d8: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
400053dc: 7f ff f3 32 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
400053e0: 01 00 00 00 nop <== NOT EXECUTED
400053e4: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400053e8: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400053ec: 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;
400053f0: 84 08 bf df and %g2, -33, %g2 <== NOT EXECUTED
400053f4: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400053f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400053fc: 12 80 00 c4 bne 4000570c <rtems_termios_ioctl+0x488> <== NOT EXECUTED
40005400: 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);
40005404: 7f ff f3 2c call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40005408: 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)) {
4000540c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005410: 80 88 64 00 btst 0x400, %g1
40005414: 02 80 00 0d be 40005448 <rtems_termios_ioctl+0x1c4>
40005418: 01 00 00 00 nop
4000541c: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
40005420: 03 00 00 04 sethi %hi(0x1000), %g1
40005424: 80 88 80 01 btst %g2, %g1
40005428: 12 80 00 08 bne 40005448 <rtems_termios_ioctl+0x1c4> <== NEVER TAKEN
4000542c: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
40005430: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005434: 82 08 7b ff and %g1, -1025, %g1
40005438: 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);
4000543c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005440: 82 08 7f fd and %g1, -3, %g1
40005444: 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)) {
40005448: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
4000544c: 80 88 61 00 btst 0x100, %g1
40005450: 02 80 00 16 be 400054a8 <rtems_termios_ioctl+0x224> <== ALWAYS TAKEN
40005454: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40005458: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000545c: 06 80 00 93 bl 400056a8 <rtems_termios_ioctl+0x424> <== NOT EXECUTED
40005460: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
40005464: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
40005468: 84 08 be ff and %g2, -257, %g2 <== NOT EXECUTED
4000546c: 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)) {
40005470: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
40005474: 80 88 a0 04 btst 4, %g2 <== NOT EXECUTED
40005478: 02 80 00 09 be 4000549c <rtems_termios_ioctl+0x218> <== NOT EXECUTED
4000547c: 01 00 00 00 nop <== NOT EXECUTED
40005480: c4 07 60 b0 ld [ %i5 + 0xb0 ], %g2 <== NOT EXECUTED
40005484: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40005488: 02 80 00 05 be 4000549c <rtems_termios_ioctl+0x218> <== NOT EXECUTED
4000548c: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
40005490: 9f c0 80 00 call %g2 <== NOT EXECUTED
40005494: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
40005498: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
4000549c: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
400054a0: 84 08 bf fb and %g2, -5, %g2 <== NOT EXECUTED
400054a4: 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) {
400054a8: 80 a0 60 00 cmp %g1, 0
400054ac: 06 80 00 7f bl 400056a8 <rtems_termios_ioctl+0x424> <== NEVER TAKEN
400054b0: 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) {
400054b4: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
400054b8: 05 00 00 04 sethi %hi(0x1000), %g2
400054bc: 80 88 40 02 btst %g1, %g2
400054c0: 02 80 00 06 be 400054d8 <rtems_termios_ioctl+0x254>
400054c4: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
400054c8: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
400054cc: 84 10 a4 00 or %g2, 0x400, %g2
400054d0: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
400054d4: 80 88 64 00 btst 0x400, %g1
400054d8: 22 80 00 06 be,a 400054f0 <rtems_termios_ioctl+0x26c>
400054dc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
400054e0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400054e4: 82 10 62 00 or %g1, 0x200, %g1
400054e8: 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) {
400054ec: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
400054f0: 80 88 60 02 btst 2, %g1
400054f4: 02 80 00 51 be 40005638 <rtems_termios_ioctl+0x3b4>
400054f8: 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;
400054fc: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
40005500: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
40005504: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
40005508: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
4000550c: 80 a0 60 00 cmp %g1, 0
40005510: 02 bf ff 89 be 40005334 <rtems_termios_ioctl+0xb0>
40005514: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
40005518: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
4000551c: 9f c0 40 00 call %g1
40005520: 92 10 00 1c mov %i4, %o1
40005524: 30 bf ff 84 b,a 40005334 <rtems_termios_ioctl+0xb0>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
40005528: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
4000552c: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
40005530: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
40005534: 0c 80 00 5a bneg 4000569c <rtems_termios_ioctl+0x418> <== NOT EXECUTED
40005538: 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;
4000553c: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
40005540: c4 07 60 24 ld [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
40005544: c6 07 20 08 ld [ %i4 + 8 ], %g3 <== NOT EXECUTED
40005548: 84 21 00 02 sub %g4, %g2, %g2 <== NOT EXECUTED
4000554c: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
}
break;
40005550: 10 bf ff 79 b 40005334 <rtems_termios_ioctl+0xb0> <== NOT EXECUTED
40005554: 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) {
40005558: 84 10 a0 1a or %g2, 0x1a, %g2
4000555c: 80 a0 40 02 cmp %g1, %g2
40005560: 02 80 00 2e be 40005618 <rtems_termios_ioctl+0x394>
40005564: 05 20 01 1d sethi %hi(0x80047400), %g2
40005568: 84 10 a0 1b or %g2, 0x1b, %g2 ! 8004741b <LEON_REG+0x4741b>
4000556c: 80 a0 40 02 cmp %g1, %g2
40005570: 32 bf ff 61 bne,a 400052f4 <rtems_termios_ioctl+0x70> <== NEVER TAKEN
40005574: 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) {
40005578: c2 07 60 cc ld [ %i5 + 0xcc ], %g1
4000557c: 37 10 00 7a sethi %hi(0x4001e800), %i3
40005580: 83 28 60 05 sll %g1, 5, %g1
40005584: b6 16 e2 ac or %i3, 0x2ac, %i3
40005588: 82 06 c0 01 add %i3, %g1, %g1
4000558c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005590: 80 a0 60 00 cmp %g1, 0
40005594: 22 80 00 06 be,a 400055ac <rtems_termios_ioctl+0x328>
40005598: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4000559c: 9f c0 40 00 call %g1
400055a0: 90 10 00 1d mov %i5, %o0
400055a4: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
400055a8: c2 07 20 08 ld [ %i4 + 8 ], %g1
400055ac: c2 00 40 00 ld [ %g1 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
400055b0: c0 27 60 d0 clr [ %i5 + 0xd0 ]
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
400055b4: 85 28 60 05 sll %g1, 5, %g2
400055b8: c4 06 c0 02 ld [ %i3 + %g2 ], %g2
400055bc: 80 a0 a0 00 cmp %g2, 0
400055c0: 02 bf ff 5d be 40005334 <rtems_termios_ioctl+0xb0>
400055c4: c2 27 60 cc st %g1, [ %i5 + 0xcc ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
400055c8: 9f c0 80 00 call %g2
400055cc: 90 10 00 1d mov %i5, %o0
400055d0: 10 bf ff 59 b 40005334 <rtems_termios_ioctl+0xb0>
400055d4: 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) {
400055d8: 02 80 00 09 be 400055fc <rtems_termios_ioctl+0x378>
400055dc: 80 a0 60 04 cmp %g1, 4
400055e0: 32 bf ff 45 bne,a 400052f4 <rtems_termios_ioctl+0x70> <== NEVER TAKEN
400055e4: 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;
400055e8: c2 06 c0 00 ld [ %i3 ], %g1
400055ec: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
400055f0: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
400055f4: 10 bf ff 50 b 40005334 <rtems_termios_ioctl+0xb0>
400055f8: 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) {
400055fc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005600: 80 a0 60 00 cmp %g1, 0
40005604: 02 bf ff 4c be 40005334 <rtems_termios_ioctl+0xb0> <== ALWAYS TAKEN
40005608: 01 00 00 00 nop
4000560c: 7f ff fd 6f call 40004bc8 <drainOutput.part.0> <== NOT EXECUTED
40005610: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005614: 30 bf ff 48 b,a 40005334 <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;
40005618: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
4000561c: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
40005620: 10 bf ff 45 b 40005334 <rtems_termios_ioctl+0xb0>
40005624: c4 20 40 00 st %g2, [ %g1 ]
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
40005628: 92 07 60 30 add %i5, 0x30, %o1
4000562c: 40 00 2a 96 call 40010084 <memcpy>
40005630: 94 10 20 24 mov 0x24, %o2
break;
40005634: 30 bf ff 40 b,a 40005334 <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;
40005638: 40 00 05 8d call 40006c6c <rtems_clock_get_ticks_per_second>
4000563c: 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] *
40005640: 40 00 4c 53 call 4001878c <.umul>
40005644: 92 10 00 1b mov %i3, %o1
rtems_clock_get_ticks_per_second() / 10;
40005648: 40 00 4c 8b call 40018874 <.udiv>
4000564c: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
40005650: 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] *
40005654: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
40005658: 80 a0 60 00 cmp %g1, 0
4000565c: 02 80 00 26 be 400056f4 <rtems_termios_ioctl+0x470>
40005660: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
40005664: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
40005668: 80 a0 60 00 cmp %g1, 0
4000566c: 12 bf ff a6 bne 40005504 <rtems_termios_ioctl+0x280>
40005670: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
40005674: 10 bf ff a5 b 40005508 <rtems_termios_ioctl+0x284>
40005678: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
4000567c: 7f ff f2 8a call 400020a4 <sparc_disable_interrupts>
40005680: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
40005684: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
40005688: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
4000568c: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
40005690: 7f ff f2 89 call 400020b4 <sparc_enable_interrupts>
40005694: 01 00 00 00 nop
40005698: 30 bf ff 27 b,a 40005334 <rtems_termios_ioctl+0xb0>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
4000569c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
400056a0: 10 bf ff a7 b 4000553c <rtems_termios_ioctl+0x2b8> <== NOT EXECUTED
400056a4: 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;
400056a8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400056ac: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
400056b0: 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) {
400056b4: 10 bf ff 81 b 400054b8 <rtems_termios_ioctl+0x234> <== NOT EXECUTED
400056b8: 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);
400056bc: 7f ff f2 7a call 400020a4 <sparc_disable_interrupts>
400056c0: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
400056c4: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
400056c8: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
400056cc: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
400056d0: 7f ff f2 79 call 400020b4 <sparc_enable_interrupts>
400056d4: 01 00 00 00 nop
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
400056d8: 7f ff f2 73 call 400020a4 <sparc_disable_interrupts>
400056dc: 01 00 00 00 nop
tty->rawInBuf.Tail = 0;
400056e0: c0 27 60 60 clr [ %i5 + 0x60 ]
tty->rawInBuf.Head = 0;
400056e4: c0 27 60 5c clr [ %i5 + 0x5c ]
rtems_interrupt_enable (level);
400056e8: 7f ff f2 73 call 400020b4 <sparc_enable_interrupts>
400056ec: 01 00 00 00 nop
400056f0: 30 bf ff 11 b,a 40005334 <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]) {
400056f4: 80 a0 60 00 cmp %g1, 0
400056f8: 32 bf ff 82 bne,a 40005500 <rtems_termios_ioctl+0x27c> <== NEVER TAKEN
400056fc: 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;
40005700: 82 10 20 01 mov 1, %g1
40005704: 10 bf ff 81 b 40005508 <rtems_termios_ioctl+0x284>
40005708: 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);
4000570c: 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)(
40005710: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
40005714: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40005718: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000571c: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40005720: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005724: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40005728: 30 bf ff 37 b,a 40005404 <rtems_termios_ioctl+0x180> <== NOT EXECUTED
40004c44 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
40004c44: 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(
40004c48: 23 10 00 7b sethi %hi(0x4001ec00), %l1
40004c4c: d0 04 61 70 ld [ %l1 + 0x170 ], %o0 ! 4001ed70 <rtems_termios_ttyMutex>
40004c50: 92 10 20 00 clr %o1
40004c54: 94 10 20 00 clr %o2
40004c58: 40 00 09 cd call 4000738c <rtems_semaphore_obtain>
40004c5c: b8 10 00 18 mov %i0, %i4
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40004c60: 80 a2 20 00 cmp %o0, 0
40004c64: 12 80 00 28 bne 40004d04 <rtems_termios_open+0xc0> <== NEVER TAKEN
40004c68: a0 10 00 08 mov %o0, %l0
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40004c6c: 25 10 00 7b sethi %hi(0x4001ec00), %l2
40004c70: f0 04 a1 78 ld [ %l2 + 0x178 ], %i0 ! 4001ed78 <rtems_termios_ttyHead>
40004c74: 80 a6 20 00 cmp %i0, 0
40004c78: 02 80 00 25 be 40004d0c <rtems_termios_open+0xc8>
40004c7c: ba 10 00 18 mov %i0, %i5
if ((tty->major == major) && (tty->minor == minor))
40004c80: 10 80 00 06 b 40004c98 <rtems_termios_open+0x54>
40004c84: 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) {
40004c88: 80 a7 60 00 cmp %i5, 0
40004c8c: 02 80 00 21 be 40004d10 <rtems_termios_open+0xcc> <== ALWAYS TAKEN
40004c90: 90 10 20 01 mov 1, %o0
if ((tty->major == major) && (tty->minor == minor))
40004c94: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
40004c98: 80 a0 40 1c cmp %g1, %i4
40004c9c: 32 bf ff fb bne,a 40004c88 <rtems_termios_open+0x44>
40004ca0: fa 07 40 00 ld [ %i5 ], %i5
40004ca4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40004ca8: 80 a0 40 19 cmp %g1, %i1
40004cac: 32 bf ff f7 bne,a 40004c88 <rtems_termios_open+0x44> <== NEVER TAKEN
40004cb0: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
40004cb4: c4 06 80 00 ld [ %i2 ], %g2
if (!tty->refcount++) {
40004cb8: c2 07 60 08 ld [ %i5 + 8 ], %g1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
40004cbc: fa 20 a0 30 st %i5, [ %g2 + 0x30 ]
if (!tty->refcount++) {
40004cc0: 84 00 60 01 add %g1, 1, %g2
40004cc4: 80 a0 60 00 cmp %g1, 0
40004cc8: 12 80 00 0d bne 40004cfc <rtems_termios_open+0xb8>
40004ccc: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
40004cd0: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40004cd4: 80 a0 60 00 cmp %g1, 0
40004cd8: 02 80 00 05 be 40004cec <rtems_termios_open+0xa8> <== ALWAYS TAKEN
40004cdc: 90 10 00 1c mov %i4, %o0
(*tty->device.firstOpen)(major, minor, arg);
40004ce0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40004ce4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004ce8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004cec: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004cf0: 80 a0 60 02 cmp %g1, 2
40004cf4: 22 80 00 9e be,a 40004f6c <rtems_termios_open+0x328>
40004cf8: 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);
40004cfc: 40 00 09 f3 call 400074c8 <rtems_semaphore_release>
40004d00: d0 04 61 70 ld [ %l1 + 0x170 ], %o0
return RTEMS_SUCCESSFUL;
}
40004d04: 81 c7 e0 08 ret
40004d08: 91 e8 00 10 restore %g0, %l0, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40004d0c: 90 10 20 01 mov 1, %o0
40004d10: 7f ff f8 17 call 40002d6c <calloc>
40004d14: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
40004d18: ba 92 20 00 orcc %o0, 0, %i5
40004d1c: 02 80 00 a9 be 40004fc0 <rtems_termios_open+0x37c>
40004d20: 03 10 00 78 sethi %hi(0x4001e000), %g1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
40004d24: c2 00 63 dc ld [ %g1 + 0x3dc ], %g1 ! 4001e3dc <rtems_termios_raw_input_size>
40004d28: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
40004d2c: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
40004d30: 7f ff f9 98 call 40003390 <malloc>
40004d34: 01 00 00 00 nop
40004d38: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
40004d3c: 80 a2 20 00 cmp %o0, 0
40004d40: 02 80 00 9e be 40004fb8 <rtems_termios_open+0x374>
40004d44: a6 10 00 08 mov %o0, %l3
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
40004d48: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004d4c: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 4001e3e0 <rtems_termios_raw_output_size>
40004d50: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
40004d54: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
40004d58: 7f ff f9 8e call 40003390 <malloc>
40004d5c: 01 00 00 00 nop
40004d60: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
40004d64: 80 a2 20 00 cmp %o0, 0
40004d68: 02 80 00 92 be 40004fb0 <rtems_termios_open+0x36c>
40004d6c: a8 10 00 08 mov %o0, %l4
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
40004d70: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004d74: 7f ff f9 87 call 40003390 <malloc>
40004d78: d0 00 63 e4 ld [ %g1 + 0x3e4 ], %o0 ! 4001e3e4 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
40004d7c: 80 a2 20 00 cmp %o0, 0
40004d80: 02 80 00 8a be 40004fa8 <rtems_termios_open+0x364>
40004d84: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
40004d88: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
40004d8c: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
40004d90: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
40004d94: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
40004d98: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
40004d9c: f0 27 40 00 st %i0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
40004da0: 80 a6 20 00 cmp %i0, 0
40004da4: 02 80 00 03 be 40004db0 <rtems_termios_open+0x16c>
40004da8: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
40004dac: fa 26 20 04 st %i5, [ %i0 + 4 ]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
40004db0: 03 10 00 7b sethi %hi(0x4001ec00), %g1
40004db4: c4 00 61 74 ld [ %g1 + 0x174 ], %g2 ! 4001ed74 <rtems_termios_ttyTail>
40004db8: 80 a0 a0 00 cmp %g2, 0
40004dbc: 02 80 00 ac be 4000506c <rtems_termios_open+0x428>
40004dc0: fa 24 a1 78 st %i5, [ %l2 + 0x178 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
40004dc4: 31 10 00 78 sethi %hi(0x4001e000), %i0
40004dc8: d0 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %o0 ! 4001e3e8 <c.6875>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40004dcc: 03 15 14 9a sethi %hi(0x54526800), %g1
40004dd0: 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;
40004dd4: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
40004dd8: f8 27 60 0c st %i4, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40004ddc: 92 10 20 01 mov 1, %o1
40004de0: 94 10 20 54 mov 0x54, %o2
40004de4: 90 12 00 01 or %o0, %g1, %o0
40004de8: 96 10 20 00 clr %o3
40004dec: 40 00 08 c0 call 400070ec <rtems_semaphore_create>
40004df0: 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)
40004df4: 80 a2 20 00 cmp %o0, 0
40004df8: 12 80 00 84 bne 40005008 <rtems_termios_open+0x3c4>
40004dfc: 03 15 14 9b sethi %hi(0x54526c00), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
40004e00: d0 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %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 (
40004e04: 82 10 63 00 or %g1, 0x300, %g1
40004e08: 92 10 20 01 mov 1, %o1
40004e0c: 94 10 20 54 mov 0x54, %o2
40004e10: 90 12 00 01 or %o0, %g1, %o0
40004e14: 96 10 20 00 clr %o3
40004e18: 40 00 08 b5 call 400070ec <rtems_semaphore_create>
40004e1c: 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)
40004e20: 80 a2 20 00 cmp %o0, 0
40004e24: 12 80 00 79 bne 40005008 <rtems_termios_open+0x3c4>
40004e28: 03 15 14 9e sethi %hi(0x54527800), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
40004e2c: d0 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %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 (
40004e30: 92 10 20 00 clr %o1
40004e34: 90 12 00 01 or %o0, %g1, %o0
40004e38: 94 10 20 20 mov 0x20, %o2
40004e3c: 96 10 20 00 clr %o3
40004e40: 40 00 08 ab call 400070ec <rtems_semaphore_create>
40004e44: 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)
40004e48: 80 a2 20 00 cmp %o0, 0
40004e4c: 12 80 00 6f bne 40005008 <rtems_termios_open+0x3c4>
40004e50: 92 10 00 1b mov %i3, %o1
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
40004e54: c0 27 60 94 clr [ %i5 + 0x94 ]
/*
* Set callbacks
*/
tty->device = *callbacks;
40004e58: 90 07 60 98 add %i5, 0x98, %o0
40004e5c: 40 00 2c 8a call 40010084 <memcpy>
40004e60: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004e64: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004e68: 80 a0 60 02 cmp %g1, 2
40004e6c: 02 80 00 69 be 40005010 <rtems_termios_open+0x3cc>
40004e70: d0 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %o0
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
40004e74: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40004e78: 80 a0 60 00 cmp %g1, 0
40004e7c: 02 80 00 58 be 40004fdc <rtems_termios_open+0x398>
40004e80: d0 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %o0
40004e84: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40004e88: 80 a0 60 02 cmp %g1, 2
40004e8c: 02 80 00 55 be 40004fe0 <rtems_termios_open+0x39c>
40004e90: 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;
40004e94: c0 27 60 b8 clr [ %i5 + 0xb8 ]
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
40004e98: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
tty->highwater = tty->rawInBuf.Size * 3/4;
40004e9c: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
/*
* Bump name characer
*/
if (c++ == 'z')
40004ea0: c6 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %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;
40004ea4: 89 28 60 01 sll %g1, 1, %g4
40004ea8: 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;
40004eac: 09 00 00 06 sethi %hi(0x1800), %g4
40004eb0: 88 11 20 05 or %g4, 5, %g4 ! 1805 <PROM_START+0x1805>
40004eb4: c8 27 60 34 st %g4, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
40004eb8: 88 10 28 bd mov 0x8bd, %g4
40004ebc: c8 27 60 38 st %g4, [ %i5 + 0x38 ]
tty->termios.c_lflag =
40004ec0: 09 00 00 20 sethi %hi(0x8000), %g4
40004ec4: 88 11 22 3b or %g4, 0x23b, %g4 ! 823b <PROM_START+0x823b>
40004ec8: c8 27 60 3c st %g4, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
40004ecc: 88 10 20 03 mov 3, %g4
40004ed0: c8 2f 60 41 stb %g4, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
40004ed4: 88 10 20 1c mov 0x1c, %g4
40004ed8: c8 2f 60 42 stb %g4, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
40004edc: 88 10 20 7f mov 0x7f, %g4
40004ee0: c8 2f 60 43 stb %g4, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
40004ee4: 88 10 20 15 mov 0x15, %g4
40004ee8: c8 2f 60 44 stb %g4, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
40004eec: 88 10 20 04 mov 4, %g4
40004ef0: 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';
40004ef4: 88 10 20 11 mov 0x11, %g4
40004ef8: c8 2f 60 49 stb %g4, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
40004efc: 88 10 20 13 mov 0x13, %g4
40004f00: c8 2f 60 4a stb %g4, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
40004f04: 88 10 20 1a mov 0x1a, %g4
40004f08: c8 2f 60 4b stb %g4, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
40004f0c: 88 10 20 12 mov 0x12, %g4
40004f10: c8 2f 60 4d stb %g4, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
40004f14: 88 10 20 0f mov 0xf, %g4
40004f18: c8 2f 60 4e stb %g4, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
40004f1c: 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;
40004f20: 85 30 a0 01 srl %g2, 1, %g2
tty->highwater = tty->rawInBuf.Size * 3/4;
40004f24: 83 30 60 02 srl %g1, 2, %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40004f28: 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';
40004f2c: c8 2f 60 4f stb %g4, [ %i5 + 0x4f ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40004f30: 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';
40004f34: 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;
40004f38: c4 27 60 bc st %g2, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
40004f3c: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40004f40: 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';
40004f44: c0 2f 60 4c clrb [ %i5 + 0x4c ]
tty->termios.c_cc[VEOL2] = '\000';
40004f48: 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';
40004f4c: 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')
40004f50: 03 10 00 78 sethi %hi(0x4001e000), %g1
40004f54: 80 a0 e0 7a cmp %g3, 0x7a
40004f58: 02 80 00 1e be 40004fd0 <rtems_termios_open+0x38c>
40004f5c: c4 0e 23 e8 ldub [ %i0 + 0x3e8 ], %g2
40004f60: 84 00 a0 01 inc %g2
40004f64: 10 bf ff 54 b 40004cb4 <rtems_termios_open+0x70>
40004f68: c4 28 63 e8 stb %g2, [ %g1 + 0x3e8 ]
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
40004f6c: 94 10 00 1d mov %i5, %o2
40004f70: 13 10 00 19 sethi %hi(0x40006400), %o1
40004f74: 40 00 0a 39 call 40007858 <rtems_task_start>
40004f78: 92 12 62 d8 or %o1, 0x2d8, %o1 ! 400066d8 <rtems_termios_rxdaemon>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40004f7c: 80 a2 20 00 cmp %o0, 0
40004f80: 12 80 00 22 bne 40005008 <rtems_termios_open+0x3c4> <== NEVER TAKEN
40004f84: 94 10 00 1d mov %i5, %o2
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
40004f88: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
40004f8c: 13 10 00 12 sethi %hi(0x40004800), %o1
40004f90: 40 00 0a 32 call 40007858 <rtems_task_start>
40004f94: 92 12 63 58 or %o1, 0x358, %o1 ! 40004b58 <rtems_termios_txdaemon>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40004f98: 80 a2 20 00 cmp %o0, 0
40004f9c: 02 bf ff 58 be 40004cfc <rtems_termios_open+0xb8> <== ALWAYS TAKEN
40004fa0: 01 00 00 00 nop
40004fa4: 30 80 00 19 b,a 40005008 <rtems_termios_open+0x3c4> <== NOT EXECUTED
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
40004fa8: 7f ff f8 20 call 40003028 <free>
40004fac: 90 10 00 14 mov %l4, %o0
free((void *)(tty->rawInBuf.theBuf));
40004fb0: 7f ff f8 1e call 40003028 <free>
40004fb4: 90 10 00 13 mov %l3, %o0
free(tty);
40004fb8: 7f ff f8 1c call 40003028 <free>
40004fbc: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
40004fc0: d0 04 61 70 ld [ %l1 + 0x170 ], %o0
40004fc4: 40 00 09 41 call 400074c8 <rtems_semaphore_release>
40004fc8: a0 10 20 1a mov 0x1a, %l0
return RTEMS_NO_MEMORY;
40004fcc: 30 bf ff 4e b,a 40004d04 <rtems_termios_open+0xc0>
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
40004fd0: 84 10 20 61 mov 0x61, %g2
40004fd4: 10 bf ff 38 b 40004cb4 <rtems_termios_open+0x70>
40004fd8: c4 28 63 e8 stb %g2, [ %g1 + 0x3e8 ]
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
40004fdc: 03 15 14 9c sethi %hi(0x54527000), %g1
40004fe0: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x14127200>
40004fe4: 92 10 20 00 clr %o1
40004fe8: 94 10 20 24 mov 0x24, %o2
40004fec: 90 12 00 01 or %o0, %g1, %o0
40004ff0: 96 10 20 00 clr %o3
40004ff4: 40 00 08 3e call 400070ec <rtems_semaphore_create>
40004ff8: 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)
40004ffc: 80 a2 20 00 cmp %o0, 0
40005000: 02 bf ff a5 be 40004e94 <rtems_termios_open+0x250> <== ALWAYS TAKEN
40005004: 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);
40005008: 40 00 0a c6 call 40007b20 <rtems_fatal_error_occurred>
4000500c: 01 00 00 00 nop
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
40005010: 03 15 1e 15 sethi %hi(0x54785400), %g1
40005014: 92 10 20 0a mov 0xa, %o1
40005018: 90 12 00 01 or %o0, %g1, %o0
4000501c: 94 10 24 00 mov 0x400, %o2
40005020: 96 10 25 00 mov 0x500, %o3
40005024: 98 10 20 00 clr %o4
40005028: 40 00 09 68 call 400075c8 <rtems_task_create>
4000502c: 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)
40005030: 80 a2 20 00 cmp %o0, 0
40005034: 12 bf ff f5 bne 40005008 <rtems_termios_open+0x3c4> <== NEVER TAKEN
40005038: 03 14 9e 15 sethi %hi(0x52785400), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
4000503c: d0 4e 23 e8 ldsb [ %i0 + 0x3e8 ], %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 (
40005040: 92 10 20 09 mov 9, %o1
40005044: 90 12 00 01 or %o0, %g1, %o0
40005048: 94 10 24 00 mov 0x400, %o2
4000504c: 96 10 25 00 mov 0x500, %o3
40005050: 98 10 20 00 clr %o4
40005054: 40 00 09 5d call 400075c8 <rtems_task_create>
40005058: 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)
4000505c: 80 a2 20 00 cmp %o0, 0
40005060: 22 bf ff 86 be,a 40004e78 <rtems_termios_open+0x234> <== ALWAYS TAKEN
40005064: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005068: 30 bf ff e8 b,a 40005008 <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;
4000506c: 10 bf ff 56 b 40004dc4 <rtems_termios_open+0x180>
40005070: fa 20 61 74 st %i5, [ %g1 + 0x174 ]
4000572c <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
4000572c: 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) {
40005730: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
40005734: 80 a0 60 00 cmp %g1, 0
40005738: 22 80 00 44 be,a 40005848 <rtems_termios_puts+0x11c>
4000573c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
40005740: 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;
40005744: 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) {
40005748: 80 a6 60 00 cmp %i1, 0
4000574c: 02 80 00 34 be 4000581c <rtems_termios_puts+0xf0> <== NEVER TAKEN
40005750: 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;
40005754: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
40005758: 40 00 4c f3 call 40018b24 <.urem>
4000575c: 90 04 20 01 add %l0, 1, %o0
rtems_interrupt_disable (level);
40005760: 7f ff f2 51 call 400020a4 <sparc_disable_interrupts>
40005764: a0 10 00 08 mov %o0, %l0
40005768: ba 10 00 08 mov %o0, %i5
while (newHead == tty->rawOutBuf.Tail) {
4000576c: f8 06 a0 84 ld [ %i2 + 0x84 ], %i4
40005770: 80 a7 00 10 cmp %i4, %l0
40005774: 32 80 00 14 bne,a 400057c4 <rtems_termios_puts+0x98>
40005778: c6 0e 00 00 ldub [ %i0 ], %g3
tty->rawOutBufState = rob_wait;
4000577c: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
rtems_interrupt_enable (level);
40005780: 7f ff f2 4d call 400020b4 <sparc_enable_interrupts>
40005784: 90 10 00 1d mov %i5, %o0
sc = rtems_semaphore_obtain(
40005788: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
4000578c: 92 10 20 00 clr %o1
40005790: 40 00 06 ff call 4000738c <rtems_semaphore_obtain>
40005794: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005798: 80 a2 20 00 cmp %o0, 0
4000579c: 12 80 00 31 bne 40005860 <rtems_termios_puts+0x134> <== NEVER TAKEN
400057a0: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
400057a4: 7f ff f2 40 call 400020a4 <sparc_disable_interrupts>
400057a8: 01 00 00 00 nop
400057ac: 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) {
400057b0: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
400057b4: 80 a0 40 1c cmp %g1, %i4
400057b8: 22 bf ff f2 be,a 40005780 <rtems_termios_puts+0x54> <== NEVER TAKEN
400057bc: 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++;
400057c0: c6 0e 00 00 ldub [ %i0 ], %g3
400057c4: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
400057c8: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
400057cc: b0 06 20 01 inc %i0
400057d0: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
400057d4: 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;
400057d8: e0 26 a0 80 st %l0, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
400057dc: 80 a0 60 00 cmp %g1, 0
400057e0: 12 80 00 0a bne 40005808 <rtems_termios_puts+0xdc>
400057e4: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
400057e8: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
400057ec: 80 88 60 10 btst 0x10, %g1
400057f0: 02 80 00 0d be 40005824 <rtems_termios_puts+0xf8> <== ALWAYS TAKEN
400057f4: 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;
400057f8: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
400057fc: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
40005800: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
40005804: e2 26 a0 94 st %l1, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
40005808: 7f ff f2 2b call 400020b4 <sparc_enable_interrupts>
4000580c: 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) {
40005810: b2 86 7f ff addcc %i1, -1, %i1
40005814: 12 bf ff d0 bne 40005754 <rtems_termios_puts+0x28>
40005818: 01 00 00 00 nop
4000581c: 81 c7 e0 08 ret
40005820: 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);
40005824: 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)(
40005828: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
4000582c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
40005830: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
40005834: 92 02 40 02 add %o1, %g2, %o1
40005838: 9f c0 40 00 call %g1
4000583c: 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;
40005840: 10 bf ff f2 b 40005808 <rtems_termios_puts+0xdc>
40005844: 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);
40005848: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
4000584c: 92 10 00 18 mov %i0, %o1
40005850: 9f c0 40 00 call %g1
40005854: 94 10 00 19 mov %i1, %o2
return;
40005858: 81 c7 e0 08 ret
4000585c: 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);
40005860: 40 00 08 b0 call 40007b20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40005fbc <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40005fbc: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005fc0: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
40005fc4: 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;
40005fc8: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
uint32_t count = args->count;
char *buffer = args->buffer;
40005fcc: e4 06 20 10 ld [ %i0 + 0x10 ], %l2
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005fd0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
40005fd4: 92 10 20 00 clr %o1
40005fd8: 40 00 04 ed call 4000738c <rtems_semaphore_obtain>
40005fdc: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40005fe0: a0 92 20 00 orcc %o0, 0, %l0
40005fe4: 12 80 00 10 bne 40006024 <rtems_termios_read+0x68> <== NEVER TAKEN
40005fe8: 03 10 00 7a sethi %hi(0x4001e800), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
40005fec: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40005ff0: 85 28 a0 05 sll %g2, 5, %g2
40005ff4: 82 10 62 ac or %g1, 0x2ac, %g1
40005ff8: 82 00 40 02 add %g1, %g2, %g1
40005ffc: c2 00 60 08 ld [ %g1 + 8 ], %g1
40006000: 80 a0 60 00 cmp %g1, 0
40006004: 02 80 00 0a be 4000602c <rtems_termios_read+0x70>
40006008: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
4000600c: 9f c0 40 00 call %g1
40006010: 92 10 00 18 mov %i0, %o1
40006014: a0 10 00 08 mov %o0, %l0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
40006018: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
4000601c: 40 00 05 2b call 400074c8 <rtems_semaphore_release>
40006020: c0 27 60 e4 clr [ %i5 + 0xe4 ]
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
40006024: 81 c7 e0 08 ret
40006028: 91 e8 00 10 restore %g0, %l0, %o0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
4000602c: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40006030: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40006034: 80 a0 80 01 cmp %g2, %g1
40006038: 22 80 00 21 be,a 400060bc <rtems_termios_read+0x100> <== ALWAYS TAKEN
4000603c: 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)) {
40006040: 80 a6 e0 00 cmp %i3, 0
40006044: 22 80 00 15 be,a 40006098 <rtems_termios_read+0xdc> <== NEVER TAKEN
40006048: b6 10 20 00 clr %i3 <== NOT EXECUTED
4000604c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40006050: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40006054: 80 a0 40 02 cmp %g1, %g2
40006058: 36 80 00 11 bge,a 4000609c <rtems_termios_read+0xe0>
4000605c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40006060: 10 80 00 06 b 40006078 <rtems_termios_read+0xbc>
40006064: a4 24 80 01 sub %l2, %g1, %l2
40006068: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
4000606c: 80 a0 80 01 cmp %g2, %g1
40006070: 24 80 00 0b ble,a 4000609c <rtems_termios_read+0xe0>
40006074: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
*buffer++ = tty->cbuf[tty->cindex++];
40006078: 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)) {
4000607c: b6 86 ff ff addcc %i3, -1, %i3
*buffer++ = tty->cbuf[tty->cindex++];
40006080: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
40006084: c4 2c 80 01 stb %g2, [ %l2 + %g1 ]
40006088: 82 00 60 01 inc %g1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
4000608c: 12 bf ff f7 bne 40006068 <rtems_termios_read+0xac>
40006090: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
40006094: b6 10 20 00 clr %i3
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
40006098: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
4000609c: 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;
400060a0: b6 20 40 1b sub %g1, %i3, %i3
400060a4: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
tty->tty_rcvwakeup = 0;
400060a8: c0 27 60 e4 clr [ %i5 + 0xe4 ]
rtems_semaphore_release (tty->isem);
400060ac: 40 00 05 07 call 400074c8 <rtems_semaphore_release>
400060b0: b0 10 00 10 mov %l0, %i0
return sc;
}
400060b4: 81 c7 e0 08 ret
400060b8: 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 &&
400060bc: 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;
400060c0: c0 27 60 20 clr [ %i5 + 0x20 ]
400060c4: c0 27 60 24 clr [ %i5 + 0x24 ]
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
400060c8: 80 a0 60 00 cmp %g1, 0
400060cc: 02 80 00 06 be 400060e4 <rtems_termios_read+0x128>
400060d0: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
400060d4: c4 07 60 b4 ld [ %i5 + 0xb4 ], %g2
400060d8: 80 a0 a0 00 cmp %g2, 0
400060dc: 22 80 00 6d be,a 40006290 <rtems_termios_read+0x2d4>
400060e0: 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;
400060e4: f8 07 60 74 ld [ %i5 + 0x74 ], %i4
rtems_status_code sc;
int wait = 1;
400060e8: 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))) {
400060ec: 23 10 00 78 sethi %hi(0x4001e000), %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);
400060f0: a6 07 60 49 add %i5, 0x49, %l3
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400060f4: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
400060f8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
400060fc: 80 a0 80 01 cmp %g2, %g1
40006100: 02 80 00 42 be 40006208 <rtems_termios_read+0x24c>
40006104: c4 04 63 e4 ld [ %l1 + 0x3e4 ], %g2
40006108: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
(tty->ccount < (CBUFSIZE-1))) {
4000610c: 84 00 bf ff add %g2, -1, %g2
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40006110: 80 a0 80 01 cmp %g2, %g1
40006114: 08 80 00 3d bleu 40006208 <rtems_termios_read+0x24c> <== NEVER TAKEN
40006118: b4 14 63 e4 or %l1, 0x3e4, %i2
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
4000611c: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
40006120: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
40006124: 40 00 4a 80 call 40018b24 <.urem>
40006128: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
4000612c: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
40006130: f8 08 40 08 ldub [ %g1 + %o0 ], %i4
tty->rawInBuf.Head = newHead;
40006134: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
40006138: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4000613c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
40006140: 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)
40006144: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
40006148: 40 00 4a 77 call 40018b24 <.urem>
4000614c: 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)
40006150: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
40006154: 80 a2 00 01 cmp %o0, %g1
40006158: 3a 80 00 18 bcc,a 400061b8 <rtems_termios_read+0x1fc> <== NEVER TAKEN
4000615c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
40006160: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006164: 82 08 7f fe and %g1, -2, %g1
40006168: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4000616c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006170: 82 08 62 02 and %g1, 0x202, %g1
40006174: 80 a0 62 02 cmp %g1, 0x202
40006178: 22 80 00 38 be,a 40006258 <rtems_termios_read+0x29c> <== NEVER TAKEN
4000617c: 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) {
40006180: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006184: 80 88 61 00 btst 0x100, %g1
40006188: 22 80 00 0c be,a 400061b8 <rtems_termios_read+0x1fc> <== ALWAYS TAKEN
4000618c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
40006190: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
40006194: 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;
40006198: 84 08 bf fb and %g2, -5, %g2 <== NOT EXECUTED
4000619c: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
400061a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400061a4: 22 80 00 05 be,a 400061b8 <rtems_termios_read+0x1fc> <== NOT EXECUTED
400061a8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
400061ac: 9f c0 40 00 call %g1 <== NOT EXECUTED
400061b0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
400061b4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
400061b8: 90 0f 20 ff and %i4, 0xff, %o0
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
400061bc: 80 88 60 02 btst 2, %g1
400061c0: 02 80 00 1d be 40006234 <rtems_termios_read+0x278> <== NEVER TAKEN
400061c4: 92 10 00 1d mov %i5, %o1
if (siproc (c, tty))
400061c8: 7f ff ff 36 call 40005ea0 <siproc>
400061cc: 01 00 00 00 nop
400061d0: 80 a2 20 00 cmp %o0, 0
400061d4: 32 80 00 02 bne,a 400061dc <rtems_termios_read+0x220>
400061d8: b2 10 20 00 clr %i1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400061dc: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
400061e0: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
400061e4: 80 a0 80 01 cmp %g2, %g1
400061e8: 02 80 00 08 be 40006208 <rtems_termios_read+0x24c>
400061ec: f8 07 60 70 ld [ %i5 + 0x70 ], %i4
(tty->ccount < (CBUFSIZE-1))) {
400061f0: c2 06 80 00 ld [ %i2 ], %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400061f4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
400061f8: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400061fc: 80 a0 80 01 cmp %g2, %g1
40006200: 0a bf ff c7 bcs 4000611c <rtems_termios_read+0x160> <== ALWAYS TAKEN
40006204: 01 00 00 00 nop
}
/*
* Wait for characters
*/
if ( wait ) {
40006208: 80 a6 60 00 cmp %i1, 0
4000620c: 02 bf ff 8e be 40006044 <rtems_termios_read+0x88>
40006210: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
40006214: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
40006218: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
4000621c: 40 00 04 5c call 4000738c <rtems_semaphore_obtain>
40006220: 94 10 00 1c mov %i4, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
40006224: 80 a2 20 00 cmp %o0, 0
40006228: 02 bf ff b3 be 400060f4 <rtems_termios_read+0x138> <== ALWAYS TAKEN
4000622c: 80 a6 e0 00 cmp %i3, 0
40006230: 30 bf ff 85 b,a 40006044 <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);
40006234: 7f ff ff 1b call 40005ea0 <siproc> <== NOT EXECUTED
40006238: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
4000623c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
40006240: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
40006244: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40006248: 06 bf ff e5 bl 400061dc <rtems_termios_read+0x220> <== NOT EXECUTED
4000624c: 01 00 00 00 nop <== NOT EXECUTED
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
40006250: 10 bf ff e3 b 400061dc <rtems_termios_read+0x220> <== NOT EXECUTED
40006254: 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)
40006258: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000625c: 22 80 00 07 be,a 40006278 <rtems_termios_read+0x2bc> <== NOT EXECUTED
40006260: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
40006264: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40006268: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
4000626c: 02 bf ff c5 be 40006180 <rtems_termios_read+0x1c4> <== NOT EXECUTED
40006270: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
40006274: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40006278: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000627c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40006280: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006284: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40006288: 10 bf ff cc b 400061b8 <rtems_termios_read+0x1fc> <== NOT EXECUTED
4000628c: 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) {
40006290: 80 88 a0 02 btst 2, %g2
40006294: 02 80 00 0e be 400062cc <rtems_termios_read+0x310>
40006298: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
4000629c: 9f c0 40 00 call %g1
400062a0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
400062a4: 80 a2 20 00 cmp %o0, 0
400062a8: 06 80 00 3a bl 40006390 <rtems_termios_read+0x3d4>
400062ac: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
400062b0: 7f ff fe fc call 40005ea0 <siproc>
400062b4: 92 10 00 1d mov %i5, %o1
400062b8: 80 a2 20 00 cmp %o0, 0
400062bc: 12 bf ff 62 bne 40006044 <rtems_termios_read+0x88>
400062c0: 80 a6 e0 00 cmp %i3, 0
400062c4: 10 bf ff f6 b 4000629c <rtems_termios_read+0x2e0>
400062c8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
400062cc: 40 00 02 70 call 40006c8c <rtems_clock_get_ticks_since_boot>
400062d0: 01 00 00 00 nop
400062d4: b8 10 00 08 mov %o0, %i4
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
400062d8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
400062dc: 9f c0 40 00 call %g1
400062e0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
400062e4: 80 a2 20 00 cmp %o0, 0
400062e8: 06 80 00 10 bl 40006328 <rtems_termios_read+0x36c>
400062ec: 90 0a 20 ff and %o0, 0xff, %o0
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
400062f0: 7f ff fe ec call 40005ea0 <siproc>
400062f4: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
400062f8: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
400062fc: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40006300: 80 a0 80 01 cmp %g2, %g1
40006304: 16 bf ff 4f bge 40006040 <rtems_termios_read+0x84>
40006308: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
4000630c: 22 bf ff f4 be,a 400062dc <rtems_termios_read+0x320> <== NEVER TAKEN
40006310: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40006314: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
40006318: 80 a0 60 00 cmp %g1, 0
4000631c: 22 bf ff f0 be,a 400062dc <rtems_termios_read+0x320> <== NEVER TAKEN
40006320: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40006324: 30 bf ff ea b,a 400062cc <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]) {
40006328: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
4000632c: 80 a0 60 00 cmp %g1, 0
40006330: 02 80 00 0d be 40006364 <rtems_termios_read+0x3a8>
40006334: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
40006338: 80 a0 60 00 cmp %g1, 0
4000633c: 02 80 00 06 be 40006354 <rtems_termios_read+0x398> <== NEVER TAKEN
40006340: 01 00 00 00 nop
40006344: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40006348: 80 a0 60 00 cmp %g1, 0
4000634c: 12 80 00 09 bne 40006370 <rtems_termios_read+0x3b4>
40006350: 01 00 00 00 nop
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
40006354: 40 00 05 5f call 400078d0 <rtems_task_wake_after>
40006358: 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);
4000635c: 10 bf ff e0 b 400062dc <rtems_termios_read+0x320>
40006360: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
40006364: 80 a0 60 00 cmp %g1, 0
40006368: 02 bf ff 37 be 40006044 <rtems_termios_read+0x88> <== NEVER TAKEN
4000636c: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
40006370: 40 00 02 47 call 40006c8c <rtems_clock_get_ticks_since_boot>
40006374: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
40006378: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
4000637c: 90 22 00 1c sub %o0, %i4, %o0
40006380: 80 a2 00 01 cmp %o0, %g1
40006384: 08 bf ff f4 bleu 40006354 <rtems_termios_read+0x398>
40006388: 80 a6 e0 00 cmp %i3, 0
4000638c: 30 bf ff 2e b,a 40006044 <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);
40006390: 40 00 05 50 call 400078d0 <rtems_task_wake_after>
40006394: 90 10 20 01 mov 1, %o0
40006398: 10 bf ff c1 b 4000629c <rtems_termios_read+0x2e0>
4000639c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40004958 <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)
{
40004958: 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))
4000495c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40004960: 82 08 64 03 and %g1, 0x403, %g1
40004964: 80 a0 64 01 cmp %g1, 0x401
40004968: 02 80 00 44 be 40004a78 <rtems_termios_refill_transmitter+0x120><== NEVER TAKEN
4000496c: 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) {
40004970: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40004974: 82 08 60 03 and %g1, 3, %g1
40004978: 80 a0 60 02 cmp %g1, 2
4000497c: 22 80 00 50 be,a 40004abc <rtems_termios_refill_transmitter+0x164><== NEVER TAKEN
40004980: 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 ) {
40004984: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
40004988: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4000498c: 80 a0 80 01 cmp %g2, %g1
40004990: 22 80 00 30 be,a 40004a50 <rtems_termios_refill_transmitter+0xf8>
40004994: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
40004998: 7f ff f5 c3 call 400020a4 <sparc_disable_interrupts>
4000499c: 01 00 00 00 nop
len = tty->t_dqlen;
400049a0: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
400049a4: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
400049a8: 7f ff f5 c3 call 400020b4 <sparc_enable_interrupts>
400049ac: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
400049b0: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
400049b4: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
400049b8: 40 00 50 5b call 40018b24 <.urem>
400049bc: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
400049c0: 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;
400049c4: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
400049c8: 80 a0 60 02 cmp %g1, 2
400049cc: 02 80 00 55 be 40004b20 <rtems_termios_refill_transmitter+0x1c8>
400049d0: b8 10 00 08 mov %o0, %i4
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
400049d4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
400049d8: 80 a0 40 1c cmp %g1, %i4
400049dc: 22 80 00 48 be,a 40004afc <rtems_termios_refill_transmitter+0x1a4>
400049e0: 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))
400049e4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400049e8: 82 08 62 10 and %g1, 0x210, %g1
400049ec: 80 a0 62 10 cmp %g1, 0x210
400049f0: 02 80 00 4f be 40004b2c <rtems_termios_refill_transmitter+0x1d4><== NEVER TAKEN
400049f4: 01 00 00 00 nop
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
400049f8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
400049fc: 80 a7 00 01 cmp %i4, %g1
40004a00: 18 80 00 1b bgu 40004a6c <rtems_termios_refill_transmitter+0x114>
40004a04: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
40004a08: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
40004a0c: 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)) {
40004a10: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40004a14: 80 88 66 00 btst 0x600, %g1
40004a18: 02 80 00 04 be 40004a28 <rtems_termios_refill_transmitter+0xd0>
40004a1c: 94 10 00 18 mov %i0, %o2
40004a20: 94 10 20 01 mov 1, %o2
nToSend = 1;
40004a24: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
40004a28: d2 07 60 7c ld [ %i5 + 0x7c ], %o1
40004a2c: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
40004a30: 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*/
40004a34: 84 10 20 01 mov 1, %g2
(*tty->device.write)(
40004a38: 92 02 40 1c add %o1, %i4, %o1
40004a3c: 9f c0 40 00 call %g1
40004a40: c4 27 60 94 st %g2, [ %i5 + 0x94 ]
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40004a44: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
40004a48: 81 c7 e0 08 ret
40004a4c: 81 e8 00 00 restore
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
40004a50: 80 a0 60 02 cmp %g1, 2
40004a54: 12 bf ff fd bne 40004a48 <rtems_termios_refill_transmitter+0xf0><== ALWAYS TAKEN
40004a58: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
40004a5c: 40 00 0a 9b call 400074c8 <rtems_semaphore_release> <== NOT EXECUTED
40004a60: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
40004a64: 81 c7 e0 08 ret <== NOT EXECUTED
40004a68: 81 e8 00 00 restore <== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
40004a6c: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
40004a70: 10 bf ff e8 b 40004a10 <rtems_termios_refill_transmitter+0xb8>
40004a74: 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);
40004a78: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
40004a7c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40004a80: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
40004a84: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004a88: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
40004a8c: 7f ff f5 86 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
40004a90: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40004a94: c4 06 20 90 ld [ %i0 + 0x90 ], %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40004a98: 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--;
40004a9c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40004aa0: 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--;
40004aa4: c4 27 60 90 st %g2, [ %i5 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40004aa8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40004aac: 7f ff f5 82 call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40004ab0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40004ab4: 81 c7 e0 08 ret <== NOT EXECUTED
40004ab8: 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);
40004abc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40004ac0: 92 06 20 49 add %i0, 0x49, %o1 <== NOT EXECUTED
40004ac4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004ac8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
40004acc: 7f ff f5 76 call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
40004ad0: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40004ad4: c4 06 20 90 ld [ %i0 + 0x90 ], %g2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40004ad8: 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--;
40004adc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40004ae0: 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--;
40004ae4: c4 27 60 90 st %g2, [ %i5 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40004ae8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40004aec: 7f ff f5 72 call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40004af0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40004af4: 81 c7 e0 08 ret <== NOT EXECUTED
40004af8: 81 e8 00 00 restore <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
40004afc: 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) {
40004b00: 80 a0 60 00 cmp %g1, 0
40004b04: 02 bf ff d0 be 40004a44 <rtems_termios_refill_transmitter+0xec><== ALWAYS TAKEN
40004b08: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
40004b0c: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
40004b10: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004b14: 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*/
40004b18: f8 27 60 84 st %i4, [ %i5 + 0x84 ] <== NOT EXECUTED
40004b1c: 30 bf ff f6 b,a 40004af4 <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);
40004b20: 40 00 0a 6a call 400074c8 <rtems_semaphore_release>
40004b24: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
40004b28: 30 bf ff ab b,a 400049d4 <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);
40004b2c: 7f ff f5 5e call 400020a4 <sparc_disable_interrupts> <== NOT EXECUTED
40004b30: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
40004b34: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
40004b38: 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;
40004b3c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
40004b40: 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;
40004b44: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
rtems_interrupt_enable(level);
40004b48: 7f ff f5 5b call 400020b4 <sparc_enable_interrupts> <== NOT EXECUTED
40004b4c: 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*/
40004b50: f8 27 60 84 st %i4, [ %i5 + 0x84 ] <== NOT EXECUTED
40004b54: 30 bf ff e8 b,a 40004af4 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
400066d8 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
400066d8: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400066dc: 10 80 00 08 b 400066fc <rtems_termios_rxdaemon+0x24>
400066e0: 96 07 bf fc add %fp, -4, %o3
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
400066e4: 9f c0 40 00 call %g1
400066e8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
400066ec: 80 a2 3f ff cmp %o0, -1
400066f0: 32 80 00 15 bne,a 40006744 <rtems_termios_rxdaemon+0x6c>
400066f4: d0 2f bf fb stb %o0, [ %fp + -5 ]
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400066f8: 96 07 bf fc add %fp, -4, %o3
400066fc: 92 10 20 02 mov 2, %o1
40006700: 94 10 20 00 clr %o2
40006704: 40 00 01 85 call 40006d18 <rtems_event_receive>
40006708: 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) {
4000670c: c2 07 bf fc ld [ %fp + -4 ], %g1
40006710: 80 88 60 01 btst 1, %g1
40006714: 22 bf ff f4 be,a 400066e4 <rtems_termios_rxdaemon+0xc> <== ALWAYS TAKEN
40006718: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
4000671c: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40006720: 40 00 03 f3 call 400076ec <rtems_task_delete> <== NOT EXECUTED
40006724: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
40006728: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
4000672c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006730: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
if (c != EOF) {
40006734: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
40006738: 22 bf ff f1 be,a 400066fc <rtems_termios_rxdaemon+0x24> <== NOT EXECUTED
4000673c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
40006740: d0 2f bf fb stb %o0, [ %fp + -5 ] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
40006744: 92 07 bf fb add %fp, -5, %o1
40006748: 90 10 00 18 mov %i0, %o0
4000674c: 7f ff ff 1a call 400063b4 <rtems_termios_enqueue_raw_characters>
40006750: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40006754: 10 bf ff ea b 400066fc <rtems_termios_rxdaemon+0x24>
40006758: 96 07 bf fc add %fp, -4, %o3
40004b58 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
40004b58: 9d e3 bf 98 save %sp, -104, %sp
40004b5c: 3b 10 00 7a sethi %hi(0x4001e800), %i5
40004b60: 10 80 00 0c b 40004b90 <rtems_termios_txdaemon+0x38>
40004b64: ba 17 62 ac or %i5, 0x2ac, %i5 ! 4001eaac <rtems_termios_linesw>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40004b68: 83 28 60 05 sll %g1, 5, %g1
40004b6c: 82 07 40 01 add %i5, %g1, %g1
40004b70: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40004b74: 80 a0 60 00 cmp %g1, 0
40004b78: 02 80 00 04 be 40004b88 <rtems_termios_txdaemon+0x30> <== ALWAYS TAKEN
40004b7c: 90 10 00 18 mov %i0, %o0
rtems_termios_linesw[tty->t_line].l_start(tty);
40004b80: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004b84: 01 00 00 00 nop <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
40004b88: 7f ff ff 74 call 40004958 <rtems_termios_refill_transmitter>
40004b8c: 90 10 00 18 mov %i0, %o0
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40004b90: 92 10 20 02 mov 2, %o1
40004b94: 94 10 20 00 clr %o2
40004b98: 96 07 bf fc add %fp, -4, %o3
40004b9c: 40 00 08 5f call 40006d18 <rtems_event_receive>
40004ba0: 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) {
40004ba4: c2 07 bf fc ld [ %fp + -4 ], %g1
40004ba8: 80 88 60 01 btst 1, %g1
40004bac: 22 bf ff ef be,a 40004b68 <rtems_termios_txdaemon+0x10> <== ALWAYS TAKEN
40004bb0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
40004bb4: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40004bb8: 40 00 0a cd call 400076ec <rtems_task_delete> <== NOT EXECUTED
40004bbc: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40004bc0: 10 bf ff ea b 40004b68 <rtems_termios_txdaemon+0x10> <== NOT EXECUTED
40004bc4: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
40005ee8 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
40005ee8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40005eec: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005ef0: 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;
40005ef4: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005ef8: 94 10 20 00 clr %o2
40005efc: 40 00 05 24 call 4000738c <rtems_semaphore_obtain>
40005f00: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40005f04: b4 92 20 00 orcc %o0, 0, %i2
40005f08: 12 80 00 0f bne 40005f44 <rtems_termios_write+0x5c> <== NEVER TAKEN
40005f0c: 03 10 00 7a sethi %hi(0x4001e800), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
40005f10: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40005f14: 85 28 a0 05 sll %g2, 5, %g2
40005f18: 82 10 62 ac or %g1, 0x2ac, %g1
40005f1c: 82 00 40 02 add %g1, %g2, %g1
40005f20: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005f24: 80 a0 60 00 cmp %g1, 0
40005f28: 02 80 00 09 be 40005f4c <rtems_termios_write+0x64>
40005f2c: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
40005f30: 9f c0 40 00 call %g1
40005f34: 92 10 00 18 mov %i0, %o1
40005f38: b4 10 00 08 mov %o0, %i2
rtems_semaphore_release (tty->osem);
40005f3c: 40 00 05 63 call 400074c8 <rtems_semaphore_release>
40005f40: 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;
}
40005f44: 81 c7 e0 08 ret
40005f48: 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) {
40005f4c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
40005f50: 80 88 60 01 btst 1, %g1
40005f54: 22 80 00 14 be,a 40005fa4 <rtems_termios_write+0xbc> <== NEVER TAKEN
40005f58: d0 1e 20 10 ldd [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
uint32_t count = args->count;
40005f5c: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
char *buffer = args->buffer;
while (count--)
40005f60: 80 a7 20 00 cmp %i4, 0
40005f64: 02 80 00 14 be 40005fb4 <rtems_termios_write+0xcc> <== NEVER TAKEN
40005f68: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
oproc (*buffer++, tty);
40005f6c: d0 0e c0 00 ldub [ %i3 ], %o0
40005f70: 92 10 00 1d mov %i5, %o1
40005f74: 7f ff fe 3e call 4000586c <oproc>
40005f78: 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--)
40005f7c: b8 87 3f ff addcc %i4, -1, %i4
40005f80: 12 bf ff fb bne 40005f6c <rtems_termios_write+0x84>
40005f84: 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;
40005f88: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
}
rtems_semaphore_release (tty->osem);
40005f8c: 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;
40005f90: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
40005f94: 40 00 05 4d call 400074c8 <rtems_semaphore_release>
40005f98: b0 10 00 1a mov %i2, %i0
return sc;
}
40005f9c: 81 c7 e0 08 ret
40005fa0: 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);
40005fa4: 7f ff fd e2 call 4000572c <rtems_termios_puts> <== NOT EXECUTED
40005fa8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
40005fac: 10 bf ff f8 b 40005f8c <rtems_termios_write+0xa4> <== NOT EXECUTED
40005fb0: 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--)
40005fb4: 10 bf ff f6 b 40005f8c <rtems_termios_write+0xa4> <== NOT EXECUTED
40005fb8: 82 10 20 00 clr %g1 <== NOT EXECUTED
4001707c <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
4001707c: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
40017080: 11 10 00 f7 sethi %hi(0x4003dc00), %o0
40017084: 92 10 00 18 mov %i0, %o1
40017088: 90 12 21 d8 or %o0, 0x1d8, %o0
4001708c: 40 00 0c fe call 4001a484 <_Objects_Get>
40017090: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40017094: c2 07 bf fc ld [ %fp + -4 ], %g1
40017098: 80 a0 60 00 cmp %g1, 0
4001709c: 12 80 00 0c bne 400170cc <rtems_timer_cancel+0x50>
400170a0: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
400170a4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400170a8: 80 a0 60 04 cmp %g1, 4
400170ac: 02 80 00 04 be 400170bc <rtems_timer_cancel+0x40> <== NEVER TAKEN
400170b0: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
400170b4: 40 00 14 ec call 4001c464 <_Watchdog_Remove>
400170b8: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
400170bc: 40 00 10 d5 call 4001b410 <_Thread_Enable_dispatch>
400170c0: b0 10 20 00 clr %i0
400170c4: 81 c7 e0 08 ret
400170c8: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400170cc: 81 c7 e0 08 ret
400170d0: 91 e8 20 04 restore %g0, 4, %o0
400175d4 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
400175d4: 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;
400175d8: 03 10 00 f7 sethi %hi(0x4003dc00), %g1
400175dc: fa 00 62 18 ld [ %g1 + 0x218 ], %i5 ! 4003de18 <_Timer_server>
if ( !timer_server )
400175e0: 80 a7 60 00 cmp %i5, 0
400175e4: 02 80 00 08 be 40017604 <rtems_timer_server_fire_when+0x30>
400175e8: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
400175ec: 39 10 00 f4 sethi %hi(0x4003d000), %i4
400175f0: 82 17 23 b8 or %i4, 0x3b8, %g1 ! 4003d3b8 <_TOD>
400175f4: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
400175f8: 80 a0 a0 00 cmp %g2, 0
400175fc: 12 80 00 04 bne 4001760c <rtems_timer_server_fire_when+0x38><== ALWAYS TAKEN
40017600: 82 10 20 0b mov 0xb, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40017604: 81 c7 e0 08 ret
40017608: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
4001760c: 80 a6 a0 00 cmp %i2, 0
40017610: 02 bf ff fd be 40017604 <rtems_timer_server_fire_when+0x30>
40017614: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
40017618: 7f ff f3 1e call 40014290 <_TOD_Validate>
4001761c: 90 10 00 19 mov %i1, %o0
40017620: 80 8a 20 ff btst 0xff, %o0
40017624: 12 80 00 04 bne 40017634 <rtems_timer_server_fire_when+0x60>
40017628: 82 10 20 14 mov 0x14, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4001762c: 81 c7 e0 08 ret
40017630: 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 );
40017634: 7f ff f2 dd call 400141a8 <_TOD_To_seconds>
40017638: 90 10 00 19 mov %i1, %o0
4001763c: b2 10 00 08 mov %o0, %i1
40017640: d0 1f 23 b8 ldd [ %i4 + 0x3b8 ], %o0
40017644: 94 10 20 00 clr %o2
40017648: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4001764c: 40 00 52 36 call 4002bf24 <__divdi3>
40017650: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
40017654: 80 a6 40 09 cmp %i1, %o1
40017658: 08 bf ff f5 bleu 4001762c <rtems_timer_server_fire_when+0x58>
4001765c: 82 10 20 14 mov 0x14, %g1
40017660: 92 10 00 18 mov %i0, %o1
40017664: 11 10 00 f7 sethi %hi(0x4003dc00), %o0
40017668: 94 07 bf fc add %fp, -4, %o2
4001766c: 40 00 0b 86 call 4001a484 <_Objects_Get>
40017670: 90 12 21 d8 or %o0, 0x1d8, %o0
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40017674: c2 07 bf fc ld [ %fp + -4 ], %g1
40017678: 80 a0 60 00 cmp %g1, 0
4001767c: 12 80 00 19 bne 400176e0 <rtems_timer_server_fire_when+0x10c>
40017680: a0 10 00 08 mov %o0, %l0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
40017684: 40 00 13 78 call 4001c464 <_Watchdog_Remove>
40017688: 90 02 20 10 add %o0, 0x10, %o0
4001768c: d0 1f 23 b8 ldd [ %i4 + 0x3b8 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
40017690: 82 10 20 03 mov 3, %g1
40017694: 94 10 20 00 clr %o2
40017698: c2 24 20 38 st %g1, [ %l0 + 0x38 ]
4001769c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400176a0: c0 24 20 18 clr [ %l0 + 0x18 ]
400176a4: 96 12 e2 00 or %o3, 0x200, %o3
the_watchdog->routine = routine;
400176a8: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
the_watchdog->id = id;
400176ac: f0 24 20 30 st %i0, [ %l0 + 0x30 ]
400176b0: 40 00 52 1d call 4002bf24 <__divdi3>
400176b4: 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 );
400176b8: 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();
400176bc: b2 26 40 09 sub %i1, %o1, %i1
(*timer_server->schedule_operation)( timer_server, the_timer );
400176c0: 90 10 00 1d mov %i5, %o0
400176c4: 92 10 00 10 mov %l0, %o1
400176c8: 9f c0 40 00 call %g1
400176cc: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
400176d0: 40 00 0f 50 call 4001b410 <_Thread_Enable_dispatch>
400176d4: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
400176d8: 10 bf ff cb b 40017604 <rtems_timer_server_fire_when+0x30>
400176dc: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
400176e0: 10 bf ff c9 b 40017604 <rtems_timer_server_fire_when+0x30>
400176e4: 82 10 20 04 mov 4, %g1
40002dd8 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
40002dd8: 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) {
40002ddc: 03 08 00 00 sethi %hi(0x20000000), %g1
40002de0: 80 8e 00 01 btst %i0, %g1
40002de4: 02 80 00 10 be 40002e24 <rtems_verror+0x4c>
40002de8: b8 10 00 18 mov %i0, %i4
if (rtems_panic_in_progress++)
40002dec: 05 10 00 7b sethi %hi(0x4001ec00), %g2
40002df0: c6 00 a1 2c ld [ %g2 + 0x12c ], %g3 ! 4001ed2c <rtems_panic_in_progress>
40002df4: 82 00 e0 01 add %g3, 1, %g1
40002df8: 80 a0 e0 00 cmp %g3, 0
40002dfc: 02 80 00 07 be 40002e18 <rtems_verror+0x40> <== ALWAYS TAKEN
40002e00: c2 20 a1 2c st %g1, [ %g2 + 0x12c ]
*
* 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;
40002e04: 03 10 00 7b sethi %hi(0x4001ec00), %g1 <== NOT EXECUTED
40002e08: c6 00 62 c0 ld [ %g1 + 0x2c0 ], %g3 ! 4001eec0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
++level;
40002e0c: 86 00 e0 01 inc %g3 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
40002e10: c6 20 62 c0 st %g3, [ %g1 + 0x2c0 ] <== 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();
40002e14: c2 00 a1 2c ld [ %g2 + 0x12c ], %g1 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
40002e18: 80 a0 60 02 cmp %g1, 2
40002e1c: 14 80 00 30 bg 40002edc <rtems_verror+0x104> <== NEVER TAKEN
40002e20: b0 10 20 00 clr %i0
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40002e24: 3b 10 00 79 sethi %hi(0x4001e400), %i5
40002e28: c2 07 61 68 ld [ %i5 + 0x168 ], %g1 ! 4001e568 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
40002e2c: 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 */
40002e30: d0 00 60 08 ld [ %g1 + 8 ], %o0
40002e34: 40 00 33 46 call 4000fb4c <fflush>
40002e38: b6 2f 00 1b andn %i4, %i3, %i3
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
40002e3c: 03 10 00 00 sethi %hi(0x40000000), %g1
40002e40: 80 8f 00 01 btst %i4, %g1
40002e44: 12 80 00 34 bne 40002f14 <rtems_verror+0x13c>
40002e48: 01 00 00 00 nop
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
40002e4c: 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);
40002e50: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
40002e54: 92 10 00 19 mov %i1, %o1
40002e58: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40002e5c: 40 00 47 b2 call 40014d24 <vfprintf>
40002e60: 94 10 00 1a mov %i2, %o2
if (status)
40002e64: 80 a6 e0 00 cmp %i3, 0
40002e68: 12 80 00 1f bne 40002ee4 <rtems_verror+0x10c>
40002e6c: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
40002e70: 80 a7 20 00 cmp %i4, 0
40002e74: 02 80 00 12 be 40002ebc <rtems_verror+0xe4>
40002e78: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
if ((local_errno > 0) && *strerror(local_errno))
40002e7c: 80 a7 20 00 cmp %i4, 0
40002e80: 04 80 00 09 ble 40002ea4 <rtems_verror+0xcc>
40002e84: 13 10 00 72 sethi %hi(0x4001c800), %o1
40002e88: 40 00 37 8b call 40010cb4 <strerror>
40002e8c: 90 10 00 1c mov %i4, %o0
40002e90: c2 4a 00 00 ldsb [ %o0 ], %g1
40002e94: 80 a0 60 00 cmp %g1, 0
40002e98: 12 80 00 23 bne 40002f24 <rtems_verror+0x14c> <== ALWAYS TAKEN
40002e9c: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40002ea0: 13 10 00 72 sethi %hi(0x4001c800), %o1 <== NOT EXECUTED
40002ea4: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40002ea8: 92 12 61 f0 or %o1, 0x1f0, %o1
40002eac: 40 00 34 24 call 4000ff3c <fprintf>
40002eb0: 94 10 00 1c mov %i4, %o2
40002eb4: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
40002eb8: c2 07 61 68 ld [ %i5 + 0x168 ], %g1
40002ebc: 13 10 00 72 sethi %hi(0x4001c800), %o1
40002ec0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40002ec4: 40 00 34 1e call 4000ff3c <fprintf>
40002ec8: 92 12 62 08 or %o1, 0x208, %o1
(void) fflush(stderr);
40002ecc: c2 07 61 68 ld [ %i5 + 0x168 ], %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");
40002ed0: b0 02 00 18 add %o0, %i0, %i0
(void) fflush(stderr);
40002ed4: 40 00 33 1e call 4000fb4c <fflush>
40002ed8: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
40002edc: 81 c7 e0 08 ret
40002ee0: 81 e8 00 00 restore
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
40002ee4: 03 10 00 79 sethi %hi(0x4001e400), %g1
40002ee8: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 ! 4001e568 <_impure_ptr>
40002eec: 90 10 00 1b mov %i3, %o0
40002ef0: 7f ff ff b4 call 40002dc0 <rtems_status_text>
40002ef4: f6 00 60 0c ld [ %g1 + 0xc ], %i3
40002ef8: 13 10 00 72 sethi %hi(0x4001c800), %o1
40002efc: 94 10 00 08 mov %o0, %o2
40002f00: 92 12 61 d0 or %o1, 0x1d0, %o1
40002f04: 40 00 34 0e call 4000ff3c <fprintf>
40002f08: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
40002f0c: 10 bf ff d9 b 40002e70 <rtems_verror+0x98>
40002f10: 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;
40002f14: 40 00 32 0b call 4000f740 <__errno>
40002f18: 01 00 00 00 nop
40002f1c: 10 bf ff cd b 40002e50 <rtems_verror+0x78>
40002f20: 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));
40002f24: 90 10 00 1c mov %i4, %o0
40002f28: 40 00 37 63 call 40010cb4 <strerror>
40002f2c: f8 00 60 0c ld [ %g1 + 0xc ], %i4
40002f30: 13 10 00 72 sethi %hi(0x4001c800), %o1
40002f34: 94 10 00 08 mov %o0, %o2
40002f38: 92 12 61 e0 or %o1, 0x1e0, %o1
40002f3c: 40 00 34 00 call 4000ff3c <fprintf>
40002f40: 90 10 00 1c mov %i4, %o0
40002f44: 10 bf ff dd b 40002eb8 <rtems_verror+0xe0>
40002f48: b0 06 00 08 add %i0, %o0, %i0
40026cfc <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
40026cfc: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
40026d00: 35 1f ff ff sethi %hi(0x7ffffc00), %i2
int sign = 0;
40026d04: b6 10 20 00 clr %i3
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
40026d08: b4 16 a3 ff or %i2, 0x3ff, %i2
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
40026d0c: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40026d10: 23 10 01 92 sethi %hi(0x40064800), %l1
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
40026d14: 21 10 01 92 sethi %hi(0x40064800), %l0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40026d18: c2 06 20 04 ld [ %i0 + 4 ], %g1
40026d1c: 82 00 7f ff add %g1, -1, %g1
40026d20: 80 a0 60 00 cmp %g1, 0
40026d24: 06 80 00 26 bl 40026dbc <scanInt+0xc0> <== NEVER TAKEN
40026d28: c2 26 20 04 st %g1, [ %i0 + 4 ]
40026d2c: c4 06 00 00 ld [ %i0 ], %g2
40026d30: d0 08 80 00 ldub [ %g2 ], %o0
40026d34: 84 00 a0 01 inc %g2
if (c == ':')
40026d38: 80 a2 20 3a cmp %o0, 0x3a
40026d3c: 02 80 00 26 be 40026dd4 <scanInt+0xd8>
40026d40: c4 26 00 00 st %g2, [ %i0 ]
break;
if (sign == 0) {
40026d44: 80 a6 e0 00 cmp %i3, 0
40026d48: 32 80 00 06 bne,a 40026d60 <scanInt+0x64>
40026d4c: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2
if (c == '-') {
40026d50: 80 a2 20 2d cmp %o0, 0x2d
40026d54: 02 80 00 32 be 40026e1c <scanInt+0x120>
40026d58: b6 10 20 01 mov 1, %i3
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
40026d5c: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2
40026d60: 84 00 80 08 add %g2, %o0, %g2
40026d64: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
40026d68: 80 88 a0 04 btst 4, %g2
40026d6c: 22 80 00 22 be,a 40026df4 <scanInt+0xf8>
40026d70: b0 10 20 00 clr %i0
return 0;
d = c - '0';
40026d74: b8 02 3f d0 add %o0, -48, %i4
if ((i > (limit / 10))
40026d78: 92 10 20 0a mov 0xa, %o1
40026d7c: 40 00 b8 b0 call 4005503c <.udiv>
40026d80: 90 10 00 1a mov %i2, %o0
40026d84: 80 a7 40 08 cmp %i5, %o0
40026d88: 38 80 00 1b bgu,a 40026df4 <scanInt+0xf8>
40026d8c: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
40026d90: 02 80 00 1b be 40026dfc <scanInt+0x100>
40026d94: 90 10 00 1a mov %i2, %o0
return 0;
i = i * 10 + d;
40026d98: 83 2f 60 01 sll %i5, 1, %g1
40026d9c: bb 2f 60 03 sll %i5, 3, %i5
40026da0: ba 00 40 1d add %g1, %i5, %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40026da4: 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;
40026da8: ba 07 00 1d add %i4, %i5, %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40026dac: 82 00 7f ff add %g1, -1, %g1
40026db0: 80 a0 60 00 cmp %g1, 0
40026db4: 16 bf ff de bge 40026d2c <scanInt+0x30> <== ALWAYS TAKEN
40026db8: c2 26 20 04 st %g1, [ %i0 + 4 ]
40026dbc: d0 04 63 c0 ld [ %l1 + 0x3c0 ], %o0 <== NOT EXECUTED
40026dc0: 40 00 68 60 call 40040f40 <__srget_r> <== NOT EXECUTED
40026dc4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
40026dc8: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
40026dcc: 12 bf ff df bne 40026d48 <scanInt+0x4c> <== NOT EXECUTED
40026dd0: 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)
40026dd4: 80 a6 e0 00 cmp %i3, 0
40026dd8: 02 80 00 07 be 40026df4 <scanInt+0xf8> <== NEVER TAKEN
40026ddc: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
40026de0: 90 10 00 1b mov %i3, %o0
40026de4: 92 10 00 1d mov %i5, %o1
40026de8: 40 00 b8 5b call 40054f54 <.umul>
40026dec: b0 10 20 01 mov 1, %i0
40026df0: d0 26 40 00 st %o0, [ %i1 ]
return 1;
40026df4: 81 c7 e0 08 ret
40026df8: 81 e8 00 00 restore
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
40026dfc: 40 00 b9 3c call 400552ec <.urem>
40026e00: 92 10 20 0a mov 0xa, %o1
40026e04: 80 a7 00 08 cmp %i4, %o0
40026e08: 08 bf ff e5 bleu 40026d9c <scanInt+0xa0> <== NEVER TAKEN
40026e0c: 83 2f 60 01 sll %i5, 1, %g1
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
40026e10: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
40026e14: 81 c7 e0 08 ret
40026e18: 81 e8 00 00 restore
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
40026e1c: b4 06 a0 01 inc %i2
continue;
40026e20: 10 bf ff be b 40026d18 <scanInt+0x1c>
40026e24: b6 10 3f ff mov -1, %i3
40026e28 <scanString>:
/**
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
40026e28: 9d e3 bf a0 save %sp, -96, %sp
int c;
*name = *bufp;
40026e2c: c2 06 80 00 ld [ %i2 ], %g1
for (;;) {
c = getc(fp);
40026e30: 3b 10 01 92 sethi %hi(0x40064800), %i5
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
int c;
*name = *bufp;
40026e34: 10 80 00 19 b 40026e98 <scanString+0x70>
40026e38: c2 26 40 00 st %g1, [ %i1 ]
for (;;) {
c = getc(fp);
40026e3c: c2 06 00 00 ld [ %i0 ], %g1
40026e40: d0 08 40 00 ldub [ %g1 ], %o0
40026e44: 82 00 60 01 inc %g1
if (c == ':') {
40026e48: 80 a2 20 3a cmp %o0, 0x3a
40026e4c: 02 80 00 1e be 40026ec4 <scanString+0x9c>
40026e50: c2 26 00 00 st %g1, [ %i0 ]
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
40026e54: 80 a2 20 0a cmp %o0, 0xa
40026e58: 02 80 00 2a be 40026f00 <scanString+0xd8>
40026e5c: 80 a2 3f ff cmp %o0, -1
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
40026e60: 02 80 00 26 be 40026ef8 <scanString+0xd0>
40026e64: 01 00 00 00 nop
return 0;
if (*nleft < 2)
40026e68: c2 06 c0 00 ld [ %i3 ], %g1
40026e6c: 80 a0 60 01 cmp %g1, 1
40026e70: 08 80 00 22 bleu 40026ef8 <scanString+0xd0>
40026e74: 01 00 00 00 nop
return 0;
**bufp = c;
40026e78: c2 06 80 00 ld [ %i2 ], %g1
40026e7c: d0 28 40 00 stb %o0, [ %g1 ]
++(*bufp);
40026e80: c4 06 80 00 ld [ %i2 ], %g2
--(*nleft);
40026e84: c2 06 c0 00 ld [ %i3 ], %g1
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
40026e88: 84 00 a0 01 inc %g2
40026e8c: c4 26 80 00 st %g2, [ %i2 ]
--(*nleft);
40026e90: 82 00 7f ff add %g1, -1, %g1
40026e94: c2 26 c0 00 st %g1, [ %i3 ]
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
40026e98: c2 06 20 04 ld [ %i0 + 4 ], %g1
40026e9c: 82 00 7f ff add %g1, -1, %g1
40026ea0: 80 a0 60 00 cmp %g1, 0
40026ea4: 16 bf ff e6 bge 40026e3c <scanString+0x14>
40026ea8: c2 26 20 04 st %g1, [ %i0 + 4 ]
40026eac: d0 07 63 c0 ld [ %i5 + 0x3c0 ], %o0
40026eb0: 40 00 68 24 call 40040f40 <__srget_r>
40026eb4: 92 10 00 18 mov %i0, %o1
if (c == ':') {
40026eb8: 80 a2 20 3a cmp %o0, 0x3a
40026ebc: 12 bf ff e7 bne 40026e58 <scanString+0x30> <== ALWAYS TAKEN
40026ec0: 80 a2 20 0a cmp %o0, 0xa
if (nlFlag)
40026ec4: 80 a7 20 00 cmp %i4, 0
40026ec8: 12 80 00 11 bne 40026f0c <scanString+0xe4>
40026ecc: b0 10 20 00 clr %i0
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
40026ed0: c2 06 80 00 ld [ %i2 ], %g1
40026ed4: c0 28 40 00 clrb [ %g1 ]
++(*bufp);
40026ed8: c4 06 80 00 ld [ %i2 ], %g2
--(*nleft);
40026edc: c2 06 c0 00 ld [ %i3 ], %g1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
40026ee0: 84 00 a0 01 inc %g2
40026ee4: c4 26 80 00 st %g2, [ %i2 ]
--(*nleft);
40026ee8: 82 00 7f ff add %g1, -1, %g1
40026eec: c2 26 c0 00 st %g1, [ %i3 ]
return 1;
40026ef0: 81 c7 e0 08 ret
40026ef4: 91 e8 20 01 restore %g0, 1, %o0
}
40026ef8: 81 c7 e0 08 ret
40026efc: 91 e8 20 00 restore %g0, 0, %o0
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
40026f00: 80 a7 20 00 cmp %i4, 0
40026f04: 12 bf ff f3 bne 40026ed0 <scanString+0xa8>
40026f08: b0 10 20 00 clr %i0
40026f0c: 81 c7 e0 08 ret
40026f10: 81 e8 00 00 restore
40026f14 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
40026f14: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40026f18: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
40026f1c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40026f20: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40026f24: 90 10 00 18 mov %i0, %o0
40026f28: 92 10 00 19 mov %i1, %o1
40026f2c: 94 07 a0 4c add %fp, 0x4c, %o2
40026f30: 7f ff ff be call 40026e28 <scanString>
40026f34: 96 07 a0 50 add %fp, 0x50, %o3
40026f38: 80 a2 20 00 cmp %o0, 0
40026f3c: 12 80 00 04 bne 40026f4c <scangr+0x38>
40026f40: 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;
40026f44: 81 c7 e0 08 ret
40026f48: 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)
40026f4c: 92 06 60 04 add %i1, 4, %o1
40026f50: 94 07 a0 4c add %fp, 0x4c, %o2
40026f54: 96 07 a0 50 add %fp, 0x50, %o3
40026f58: 7f ff ff b4 call 40026e28 <scanString>
40026f5c: 98 10 20 00 clr %o4
40026f60: 80 a2 20 00 cmp %o0, 0
40026f64: 02 bf ff f8 be 40026f44 <scangr+0x30> <== NEVER TAKEN
40026f68: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
40026f6c: 7f ff ff 64 call 40026cfc <scanInt>
40026f70: 92 07 bf f8 add %fp, -8, %o1
40026f74: 80 a2 20 00 cmp %o0, 0
40026f78: 02 bf ff f3 be 40026f44 <scangr+0x30> <== NEVER TAKEN
40026f7c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
40026f80: 92 07 bf fc add %fp, -4, %o1
40026f84: 94 07 a0 4c add %fp, 0x4c, %o2
40026f88: 96 07 a0 50 add %fp, 0x50, %o3
40026f8c: 7f ff ff a7 call 40026e28 <scanString>
40026f90: 98 10 20 01 mov 1, %o4
40026f94: 80 a2 20 00 cmp %o0, 0
40026f98: 02 bf ff eb be 40026f44 <scangr+0x30> <== NEVER TAKEN
40026f9c: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40026fa0: 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;
40026fa4: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40026fa8: c6 0f 40 00 ldub [ %i5 ], %g3
40026fac: 83 28 e0 18 sll %g3, 0x18, %g1
40026fb0: 80 a0 60 00 cmp %g1, 0
40026fb4: 02 80 00 10 be 40026ff4 <scangr+0xe0> <== NEVER TAKEN
40026fb8: 88 10 20 17 mov 0x17, %g4
40026fbc: 84 10 00 1d mov %i5, %g2
40026fc0: 88 10 20 01 mov 1, %g4
40026fc4: 84 00 a0 01 inc %g2
40026fc8: c6 08 80 00 ldub [ %g2 ], %g3
if(*cp == ',')
40026fcc: 83 38 60 18 sra %g1, 0x18, %g1
memcount++;
40026fd0: 82 18 60 2c xor %g1, 0x2c, %g1
40026fd4: 80 a0 00 01 cmp %g0, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40026fd8: 83 28 e0 18 sll %g3, 0x18, %g1
if(*cp == ',')
memcount++;
40026fdc: 88 61 3f ff subx %g4, -1, %g4
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40026fe0: 80 a0 60 00 cmp %g1, 0
40026fe4: 32 bf ff f9 bne,a 40026fc8 <scangr+0xb4>
40026fe8: 84 00 a0 01 inc %g2
40026fec: 89 29 20 02 sll %g4, 2, %g4
40026ff0: 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))
40026ff4: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
40026ff8: 80 a0 40 04 cmp %g1, %g4
40026ffc: 0a bf ff d2 bcs 40026f44 <scangr+0x30> <== NEVER TAKEN
40027000: c2 07 a0 4c ld [ %fp + 0x4c ], %g1
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
40027004: 82 00 60 0f add %g1, 0xf, %g1
40027008: 82 08 7f f0 and %g1, -16, %g1
4002700c: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
40027010: fa 20 40 00 st %i5, [ %g1 ]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40027014: c2 07 bf fc ld [ %fp + -4 ], %g1
40027018: c4 08 40 00 ldub [ %g1 ], %g2
4002701c: 85 28 a0 18 sll %g2, 0x18, %g2
40027020: 80 a0 a0 00 cmp %g2, 0
40027024: 02 80 00 18 be 40027084 <scangr+0x170> <== NEVER TAKEN
40027028: 82 00 60 01 inc %g1
4002702c: 10 80 00 07 b 40027048 <scangr+0x134>
40027030: 86 10 20 01 mov 1, %g3
40027034: c4 08 40 00 ldub [ %g1 ], %g2
40027038: 85 28 a0 18 sll %g2, 0x18, %g2
4002703c: 80 a0 a0 00 cmp %g2, 0
40027040: 02 80 00 0c be 40027070 <scangr+0x15c>
40027044: 82 00 60 01 inc %g1
if(*cp == ',') {
40027048: 85 38 a0 18 sra %g2, 0x18, %g2
4002704c: 80 a0 a0 2c cmp %g2, 0x2c
40027050: 32 bf ff fa bne,a 40027038 <scangr+0x124>
40027054: c4 08 40 00 ldub [ %g1 ], %g2
*cp = '\0';
40027058: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
4002705c: c8 06 60 0c ld [ %i1 + 0xc ], %g4
40027060: 85 28 e0 02 sll %g3, 2, %g2
40027064: 86 00 e0 01 inc %g3
40027068: 10 bf ff f3 b 40027034 <scangr+0x120>
4002706c: c2 21 00 02 st %g1, [ %g4 + %g2 ]
40027070: 87 28 e0 02 sll %g3, 2, %g3
}
}
grp->gr_mem[memcount] = NULL;
40027074: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40027078: c0 20 40 03 clr [ %g1 + %g3 ]
return 1;
}
4002707c: 81 c7 e0 08 ret
40027080: 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++) {
40027084: 10 bf ff fc b 40027074 <scangr+0x160> <== NOT EXECUTED
40027088: 86 10 20 04 mov 4, %g3 <== NOT EXECUTED
4002708c <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
4002708c: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40027090: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40027094: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40027098: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
4002709c: 90 10 00 18 mov %i0, %o0
400270a0: 92 10 00 19 mov %i1, %o1
400270a4: 94 07 a0 4c add %fp, 0x4c, %o2
400270a8: 7f ff ff 60 call 40026e28 <scanString>
400270ac: 96 07 a0 50 add %fp, 0x50, %o3
400270b0: 80 a2 20 00 cmp %o0, 0
400270b4: 12 80 00 04 bne 400270c4 <scanpw+0x38>
400270b8: 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;
400270bc: 81 c7 e0 08 ret
400270c0: 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)
400270c4: 92 06 60 04 add %i1, 4, %o1
400270c8: 94 07 a0 4c add %fp, 0x4c, %o2
400270cc: 96 07 a0 50 add %fp, 0x50, %o3
400270d0: 7f ff ff 56 call 40026e28 <scanString>
400270d4: 98 10 20 00 clr %o4
400270d8: 80 a2 20 00 cmp %o0, 0
400270dc: 02 bf ff f8 be 400270bc <scanpw+0x30> <== NEVER TAKEN
400270e0: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
400270e4: 7f ff ff 06 call 40026cfc <scanInt>
400270e8: 92 07 bf f8 add %fp, -8, %o1
400270ec: 80 a2 20 00 cmp %o0, 0
400270f0: 02 bf ff f3 be 400270bc <scanpw+0x30>
400270f4: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
400270f8: 7f ff ff 01 call 40026cfc <scanInt>
400270fc: 92 07 bf fc add %fp, -4, %o1
40027100: 80 a2 20 00 cmp %o0, 0
40027104: 02 bf ff ee be 400270bc <scanpw+0x30>
40027108: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
4002710c: 92 06 60 0c add %i1, 0xc, %o1
40027110: 94 07 a0 4c add %fp, 0x4c, %o2
40027114: 96 07 a0 50 add %fp, 0x50, %o3
40027118: 7f ff ff 44 call 40026e28 <scanString>
4002711c: 98 10 20 00 clr %o4
40027120: 80 a2 20 00 cmp %o0, 0
40027124: 02 bf ff e6 be 400270bc <scanpw+0x30> <== NEVER TAKEN
40027128: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
4002712c: 92 06 60 10 add %i1, 0x10, %o1
40027130: 94 07 a0 4c add %fp, 0x4c, %o2
40027134: 96 07 a0 50 add %fp, 0x50, %o3
40027138: 7f ff ff 3c call 40026e28 <scanString>
4002713c: 98 10 20 00 clr %o4
40027140: 80 a2 20 00 cmp %o0, 0
40027144: 02 bf ff de be 400270bc <scanpw+0x30> <== NEVER TAKEN
40027148: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
4002714c: 92 06 60 14 add %i1, 0x14, %o1
40027150: 94 07 a0 4c add %fp, 0x4c, %o2
40027154: 96 07 a0 50 add %fp, 0x50, %o3
40027158: 7f ff ff 34 call 40026e28 <scanString>
4002715c: 98 10 20 00 clr %o4
40027160: 80 a2 20 00 cmp %o0, 0
40027164: 02 bf ff d6 be 400270bc <scanpw+0x30> <== NEVER TAKEN
40027168: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
4002716c: 92 06 60 18 add %i1, 0x18, %o1
40027170: 94 07 a0 4c add %fp, 0x4c, %o2
40027174: 96 07 a0 50 add %fp, 0x50, %o3
40027178: 7f ff ff 2c call 40026e28 <scanString>
4002717c: 98 10 20 01 mov 1, %o4
40027180: 80 a2 20 00 cmp %o0, 0
40027184: 02 bf ff ce be 400270bc <scanpw+0x30>
40027188: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
4002718c: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
40027190: c2 07 bf fc ld [ %fp + -4 ], %g1
40027194: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
40027198: 81 c7 e0 08 ret
4002719c: 91 e8 20 01 restore %g0, 1, %o0
400077dc <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
400077dc: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
400077e0: 80 a6 20 04 cmp %i0, 4
400077e4: 08 80 00 08 bleu 40007804 <sched_get_priority_max+0x28>
400077e8: 82 10 20 01 mov 1, %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
400077ec: 40 00 22 40 call 400100ec <__errno>
400077f0: b0 10 3f ff mov -1, %i0
400077f4: 82 10 20 16 mov 0x16, %g1
400077f8: c2 22 00 00 st %g1, [ %o0 ]
400077fc: 81 c7 e0 08 ret
40007800: 81 e8 00 00 restore
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
40007804: b1 28 40 18 sll %g1, %i0, %i0
40007808: 80 8e 20 17 btst 0x17, %i0
4000780c: 02 bf ff f8 be 400077ec <sched_get_priority_max+0x10> <== NEVER TAKEN
40007810: 03 10 00 7b sethi %hi(0x4001ec00), %g1
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
40007814: f0 08 61 fc ldub [ %g1 + 0x1fc ], %i0 ! 4001edfc <rtems_maximum_priority>
}
40007818: 81 c7 e0 08 ret
4000781c: 91 ee 3f ff restore %i0, -1, %o0
40007820 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
40007820: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
40007824: 80 a6 20 04 cmp %i0, 4
40007828: 08 80 00 08 bleu 40007848 <sched_get_priority_min+0x28>
4000782c: 82 10 00 18 mov %i0, %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40007830: 40 00 22 2f call 400100ec <__errno>
40007834: b0 10 3f ff mov -1, %i0
40007838: 82 10 20 16 mov 0x16, %g1
4000783c: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
40007840: 81 c7 e0 08 ret
40007844: 81 e8 00 00 restore
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
40007848: 84 10 20 01 mov 1, %g2
4000784c: 83 28 80 01 sll %g2, %g1, %g1
40007850: 80 88 60 17 btst 0x17, %g1
40007854: 02 bf ff f7 be 40007830 <sched_get_priority_min+0x10> <== NEVER TAKEN
40007858: b0 10 20 01 mov 1, %i0
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
4000785c: 81 c7 e0 08 ret
40007860: 81 e8 00 00 restore
40007864 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
40007864: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
40007868: 80 a6 20 00 cmp %i0, 0
4000786c: 12 80 00 0a bne 40007894 <sched_rr_get_interval+0x30> <== ALWAYS TAKEN
40007870: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
40007874: 02 80 00 13 be 400078c0 <sched_rr_get_interval+0x5c>
40007878: 03 10 00 7e sethi %hi(0x4001f800), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
4000787c: d0 00 61 10 ld [ %g1 + 0x110 ], %o0 ! 4001f910 <_Thread_Ticks_per_timeslice>
40007880: 92 10 00 19 mov %i1, %o1
40007884: 40 00 0f 59 call 4000b5e8 <_Timespec_From_ticks>
40007888: b0 10 20 00 clr %i0
return 0;
}
4000788c: 81 c7 e0 08 ret
40007890: 81 e8 00 00 restore
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
40007894: 7f ff ee ed call 40003448 <getpid>
40007898: 01 00 00 00 nop
4000789c: 80 a2 00 18 cmp %o0, %i0
400078a0: 02 bf ff f5 be 40007874 <sched_rr_get_interval+0x10>
400078a4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
400078a8: 40 00 22 11 call 400100ec <__errno>
400078ac: b0 10 3f ff mov -1, %i0
400078b0: 82 10 20 03 mov 3, %g1
400078b4: c2 22 00 00 st %g1, [ %o0 ]
400078b8: 81 c7 e0 08 ret
400078bc: 81 e8 00 00 restore
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
400078c0: 40 00 22 0b call 400100ec <__errno>
400078c4: b0 10 3f ff mov -1, %i0
400078c8: 82 10 20 16 mov 0x16, %g1
400078cc: c2 22 00 00 st %g1, [ %o0 ]
400078d0: 81 c7 e0 08 ret
400078d4: 81 e8 00 00 restore
4000812c <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
4000812c: 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;
40008130: 03 10 00 8e sethi %hi(0x40023800), %g1
40008134: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 400238c0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40008138: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
4000813c: 84 00 a0 01 inc %g2
40008140: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40008144: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40008148: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
4000814c: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
40008150: b4 8e 62 00 andcc %i1, 0x200, %i2
40008154: 12 80 00 27 bne 400081f0 <sem_open+0xc4>
40008158: 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 );
4000815c: 39 10 00 8e sethi %hi(0x40023800), %i4
40008160: 92 10 00 18 mov %i0, %o1
40008164: 90 17 23 84 or %i4, 0x384, %o0
40008168: 94 07 bf f0 add %fp, -16, %o2
4000816c: 7f ff fe 5c call 40007adc <_POSIX_Name_to_id>
40008170: 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 ) {
40008174: ba 92 20 00 orcc %o0, 0, %i5
40008178: 22 80 00 0e be,a 400081b0 <sem_open+0x84>
4000817c: 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) ) ) {
40008180: 80 a7 60 02 cmp %i5, 2
40008184: 12 80 00 04 bne 40008194 <sem_open+0x68>
40008188: 80 a6 a0 00 cmp %i2, 0
4000818c: 12 80 00 1d bne 40008200 <sem_open+0xd4>
40008190: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
40008194: 40 00 0e 73 call 4000bb60 <_Thread_Enable_dispatch>
40008198: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
4000819c: 40 00 25 30 call 4001165c <__errno>
400081a0: 01 00 00 00 nop
400081a4: fa 22 00 00 st %i5, [ %o0 ]
400081a8: 81 c7 e0 08 ret
400081ac: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
400081b0: 80 a6 6a 00 cmp %i1, 0xa00
400081b4: 02 80 00 1f be 40008230 <sem_open+0x104>
400081b8: 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 *)
400081bc: 94 07 bf f8 add %fp, -8, %o2
400081c0: 40 00 0a 7a call 4000aba8 <_Objects_Get>
400081c4: 90 17 23 84 or %i4, 0x384, %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;
400081c8: 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 );
400081cc: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
400081d0: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
400081d4: 40 00 0e 63 call 4000bb60 <_Thread_Enable_dispatch>
400081d8: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
400081dc: 40 00 0e 61 call 4000bb60 <_Thread_Enable_dispatch>
400081e0: 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;
400081e4: f0 07 bf f4 ld [ %fp + -12 ], %i0
400081e8: 81 c7 e0 08 ret
400081ec: 91 ee 20 08 restore %i0, 8, %o0
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
400081f0: 82 07 a0 4c add %fp, 0x4c, %g1
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
400081f4: f6 07 a0 50 ld [ %fp + 0x50 ], %i3
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
400081f8: 10 bf ff d9 b 4000815c <sem_open+0x30>
400081fc: 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(
40008200: 94 10 20 00 clr %o2
40008204: 96 10 00 1b mov %i3, %o3
40008208: 98 07 bf f4 add %fp, -12, %o4
4000820c: 40 00 1a b9 call 4000ecf0 <_POSIX_Semaphore_Create_support>
40008210: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
40008214: 40 00 0e 53 call 4000bb60 <_Thread_Enable_dispatch>
40008218: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
4000821c: 80 a7 7f ff cmp %i5, -1
40008220: 32 bf ff f2 bne,a 400081e8 <sem_open+0xbc> <== ALWAYS TAKEN
40008224: 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
}
40008228: 81 c7 e0 08 ret <== NOT EXECUTED
4000822c: 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();
40008230: 40 00 0e 4c call 4000bb60 <_Thread_Enable_dispatch>
40008234: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
40008238: 40 00 25 09 call 4001165c <__errno>
4000823c: 01 00 00 00 nop
40008240: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
40008244: c2 22 00 00 st %g1, [ %o0 ]
40008248: 81 c7 e0 08 ret
4000824c: 81 e8 00 00 restore
4000a284 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
4000a284: 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 );
4000a288: 90 10 00 19 mov %i1, %o0
4000a28c: 40 00 16 6f call 4000fc48 <_POSIX_Absolute_timeout_to_ticks>
4000a290: 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 );
4000a294: 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 )
4000a298: 80 a2 20 03 cmp %o0, 3
4000a29c: 02 80 00 06 be 4000a2b4 <sem_timedwait+0x30> <== ALWAYS TAKEN
4000a2a0: 90 10 00 18 mov %i0, %o0
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
4000a2a4: 40 00 19 69 call 40010848 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
4000a2a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000a2ac: 81 c7 e0 08 ret <== NOT EXECUTED
4000a2b0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000a2b4: 40 00 19 65 call 40010848 <_POSIX_Semaphore_Wait_support>
4000a2b8: 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;
}
4000a2bc: 81 c7 e0 08 ret
4000a2c0: 91 e8 00 08 restore %g0, %o0, %o0
40007790 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
40007790: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
40007794: 80 a6 a0 00 cmp %i2, 0
40007798: 02 80 00 0d be 400077cc <sigaction+0x3c>
4000779c: 87 2e 20 02 sll %i0, 2, %g3
*oact = _POSIX_signals_Vectors[ sig ];
400077a0: 05 10 00 6a sethi %hi(0x4001a800), %g2
400077a4: 83 2e 20 04 sll %i0, 4, %g1
400077a8: 84 10 a1 70 or %g2, 0x170, %g2
400077ac: 82 20 40 03 sub %g1, %g3, %g1
400077b0: c6 00 80 01 ld [ %g2 + %g1 ], %g3
400077b4: 82 00 80 01 add %g2, %g1, %g1
400077b8: c6 26 80 00 st %g3, [ %i2 ]
400077bc: c4 00 60 04 ld [ %g1 + 4 ], %g2
400077c0: c4 26 a0 04 st %g2, [ %i2 + 4 ]
400077c4: c2 00 60 08 ld [ %g1 + 8 ], %g1
400077c8: c2 26 a0 08 st %g1, [ %i2 + 8 ]
if ( !sig )
400077cc: 80 a6 20 00 cmp %i0, 0
400077d0: 02 80 00 33 be 4000789c <sigaction+0x10c>
400077d4: 01 00 00 00 nop
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
400077d8: 82 06 3f ff add %i0, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
400077dc: 80 a0 60 1f cmp %g1, 0x1f
400077e0: 18 80 00 2f bgu 4000789c <sigaction+0x10c>
400077e4: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
400077e8: 02 80 00 2d be 4000789c <sigaction+0x10c>
400077ec: 80 a6 60 00 cmp %i1, 0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
400077f0: 02 80 00 1a be 40007858 <sigaction+0xc8> <== NEVER TAKEN
400077f4: 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 );
400077f8: 7f ff eb 17 call 40002454 <sparc_disable_interrupts>
400077fc: 01 00 00 00 nop
40007800: ba 10 00 08 mov %o0, %i5
if ( act->sa_handler == SIG_DFL ) {
40007804: c2 06 60 08 ld [ %i1 + 8 ], %g1
40007808: 80 a0 60 00 cmp %g1, 0
4000780c: 02 80 00 15 be 40007860 <sigaction+0xd0>
40007810: 83 2e 20 02 sll %i0, 2, %g1
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
40007814: 40 00 17 c0 call 4000d714 <_POSIX_signals_Clear_process_signals>
40007818: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
4000781c: c4 06 40 00 ld [ %i1 ], %g2
40007820: 87 2e 20 02 sll %i0, 2, %g3
40007824: 03 10 00 6a sethi %hi(0x4001a800), %g1
40007828: b1 2e 20 04 sll %i0, 4, %i0
4000782c: 82 10 61 70 or %g1, 0x170, %g1
40007830: b0 26 00 03 sub %i0, %g3, %i0
40007834: c4 20 40 18 st %g2, [ %g1 + %i0 ]
40007838: c4 06 60 04 ld [ %i1 + 4 ], %g2
4000783c: b0 00 40 18 add %g1, %i0, %i0
40007840: c4 26 20 04 st %g2, [ %i0 + 4 ]
40007844: c2 06 60 08 ld [ %i1 + 8 ], %g1
40007848: c2 26 20 08 st %g1, [ %i0 + 8 ]
}
_ISR_Enable( level );
4000784c: 7f ff eb 06 call 40002464 <sparc_enable_interrupts>
40007850: 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;
40007854: 82 10 20 00 clr %g1
}
40007858: 81 c7 e0 08 ret
4000785c: 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 ];
40007860: b1 2e 20 04 sll %i0, 4, %i0
40007864: b0 26 00 01 sub %i0, %g1, %i0
40007868: 03 10 00 64 sethi %hi(0x40019000), %g1
4000786c: 82 10 60 54 or %g1, 0x54, %g1 ! 40019054 <_POSIX_signals_Default_vectors>
40007870: c8 00 40 18 ld [ %g1 + %i0 ], %g4
40007874: 82 00 40 18 add %g1, %i0, %g1
40007878: c6 00 60 04 ld [ %g1 + 4 ], %g3
4000787c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40007880: 03 10 00 6a sethi %hi(0x4001a800), %g1
40007884: 82 10 61 70 or %g1, 0x170, %g1 ! 4001a970 <_POSIX_signals_Vectors>
40007888: c8 20 40 18 st %g4, [ %g1 + %i0 ]
4000788c: b0 00 40 18 add %g1, %i0, %i0
40007890: c6 26 20 04 st %g3, [ %i0 + 4 ]
40007894: 10 bf ff ee b 4000784c <sigaction+0xbc>
40007898: 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 );
4000789c: 40 00 23 2a call 40010544 <__errno>
400078a0: 01 00 00 00 nop
400078a4: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
400078a8: 82 10 3f ff mov -1, %g1
400078ac: 10 bf ff eb b 40007858 <sigaction+0xc8>
400078b0: c4 22 00 00 st %g2, [ %o0 ]
40007d20 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
40007d20: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
40007d24: ba 96 20 00 orcc %i0, 0, %i5
40007d28: 02 80 00 83 be 40007f34 <sigtimedwait+0x214>
40007d2c: 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 ) {
40007d30: 02 80 00 5b be 40007e9c <sigtimedwait+0x17c>
40007d34: 80 a6 60 00 cmp %i1, 0
if ( !_Timespec_Is_valid( timeout ) )
40007d38: 40 00 0f 9d call 4000bbac <_Timespec_Is_valid>
40007d3c: 90 10 00 1a mov %i2, %o0
40007d40: 80 8a 20 ff btst 0xff, %o0
40007d44: 02 80 00 7c be 40007f34 <sigtimedwait+0x214>
40007d48: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
40007d4c: 40 00 0f ab call 4000bbf8 <_Timespec_To_ticks>
40007d50: 90 10 00 1a mov %i2, %o0
if ( !interval )
40007d54: b0 92 20 00 orcc %o0, 0, %i0
40007d58: 02 80 00 77 be 40007f34 <sigtimedwait+0x214> <== NEVER TAKEN
40007d5c: 80 a6 60 00 cmp %i1, 0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
40007d60: 02 80 00 52 be 40007ea8 <sigtimedwait+0x188> <== NEVER TAKEN
40007d64: 35 10 00 6c sethi %hi(0x4001b000), %i2
the_thread = _Thread_Executing;
40007d68: 35 10 00 6c sethi %hi(0x4001b000), %i2
40007d6c: b4 16 a1 70 or %i2, 0x170, %i2 ! 4001b170 <_Per_CPU_Information>
40007d70: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
40007d74: 7f ff ea 93 call 400027c0 <sparc_disable_interrupts>
40007d78: f6 07 21 50 ld [ %i4 + 0x150 ], %i3
40007d7c: a0 10 00 08 mov %o0, %l0
if ( *set & api->signals_pending ) {
40007d80: c2 07 40 00 ld [ %i5 ], %g1
40007d84: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2
40007d88: 80 88 40 02 btst %g1, %g2
40007d8c: 12 80 00 52 bne 40007ed4 <sigtimedwait+0x1b4>
40007d90: 01 00 00 00 nop
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
40007d94: 05 10 00 6c sethi %hi(0x4001b000), %g2
40007d98: c4 00 a3 c4 ld [ %g2 + 0x3c4 ], %g2 ! 4001b3c4 <_POSIX_signals_Pending>
40007d9c: 80 88 40 02 btst %g1, %g2
40007da0: 12 80 00 2e bne 40007e58 <sigtimedwait+0x138>
40007da4: 03 10 00 6b sethi %hi(0x4001ac00), %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;
40007da8: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 4001ac60 <_Thread_Dispatch_disable_level>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
40007dac: 86 10 3f ff mov -1, %g3
40007db0: c6 26 40 00 st %g3, [ %i1 ]
++level;
40007db4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007db8: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
40007dbc: 82 10 20 04 mov 4, %g1
40007dc0: c2 27 20 34 st %g1, [ %i4 + 0x34 ]
the_thread->Wait.option = *set;
40007dc4: c2 07 40 00 ld [ %i5 ], %g1
the_thread->Wait.return_argument = the_info;
40007dc8: 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;
40007dcc: 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;
40007dd0: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
40007dd4: 21 10 00 6c sethi %hi(0x4001b000), %l0
40007dd8: a0 14 23 5c or %l0, 0x35c, %l0 ! 4001b35c <_POSIX_signals_Wait_queue>
40007ddc: e0 27 20 44 st %l0, [ %i4 + 0x44 ]
40007de0: 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 );
40007de4: 7f ff ea 7b call 400027d0 <sparc_enable_interrupts>
40007de8: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
40007dec: 90 10 00 10 mov %l0, %o0
40007df0: 92 10 00 18 mov %i0, %o1
40007df4: 15 10 00 2e sethi %hi(0x4000b800), %o2
40007df8: 40 00 0d ff call 4000b5f4 <_Thread_queue_Enqueue_with_handler>
40007dfc: 94 12 a1 d4 or %o2, 0x1d4, %o2 ! 4000b9d4 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
40007e00: 40 00 0c bd call 4000b0f4 <_Thread_Enable_dispatch>
40007e04: 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 );
40007e08: d2 06 40 00 ld [ %i1 ], %o1
40007e0c: 90 10 00 1b mov %i3, %o0
40007e10: 94 10 00 19 mov %i1, %o2
40007e14: 96 10 20 00 clr %o3
40007e18: 40 00 18 7c call 4000e008 <_POSIX_signals_Clear_signals>
40007e1c: 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)
40007e20: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40007e24: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40007e28: 80 a0 60 04 cmp %g1, 4
40007e2c: 12 80 00 3b bne 40007f18 <sigtimedwait+0x1f8>
40007e30: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
40007e34: f0 06 40 00 ld [ %i1 ], %i0
40007e38: c2 07 40 00 ld [ %i5 ], %g1
40007e3c: 84 06 3f ff add %i0, -1, %g2
40007e40: a3 2c 40 02 sll %l1, %g2, %l1
40007e44: 80 8c 40 01 btst %l1, %g1
40007e48: 02 80 00 34 be 40007f18 <sigtimedwait+0x1f8>
40007e4c: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
40007e50: 81 c7 e0 08 ret
40007e54: 81 e8 00 00 restore
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
40007e58: 7f ff ff 9a call 40007cc0 <_POSIX_signals_Get_lowest>
40007e5c: 90 10 00 02 mov %g2, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40007e60: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
40007e64: b0 10 00 08 mov %o0, %i0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40007e68: 96 10 20 01 mov 1, %o3
40007e6c: 90 10 00 1b mov %i3, %o0
40007e70: 92 10 00 18 mov %i0, %o1
40007e74: 40 00 18 65 call 4000e008 <_POSIX_signals_Clear_signals>
40007e78: 98 10 20 00 clr %o4
_ISR_Enable( level );
40007e7c: 7f ff ea 55 call 400027d0 <sparc_enable_interrupts>
40007e80: 90 10 00 10 mov %l0, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
40007e84: 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;
40007e88: f0 26 40 00 st %i0, [ %i1 ]
the_info->si_code = SI_USER;
40007e8c: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
40007e90: c0 26 60 08 clr [ %i1 + 8 ]
40007e94: 81 c7 e0 08 ret
40007e98: 81 e8 00 00 restore
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
40007e9c: 12 bf ff b3 bne 40007d68 <sigtimedwait+0x48>
40007ea0: b0 10 20 00 clr %i0
the_thread = _Thread_Executing;
40007ea4: 35 10 00 6c sethi %hi(0x4001b000), %i2
40007ea8: b4 16 a1 70 or %i2, 0x170, %i2 ! 4001b170 <_Per_CPU_Information>
40007eac: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
40007eb0: b2 07 bf f4 add %fp, -12, %i1
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
40007eb4: 7f ff ea 43 call 400027c0 <sparc_disable_interrupts>
40007eb8: f6 07 21 50 ld [ %i4 + 0x150 ], %i3
40007ebc: a0 10 00 08 mov %o0, %l0
if ( *set & api->signals_pending ) {
40007ec0: c2 07 40 00 ld [ %i5 ], %g1
40007ec4: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2
40007ec8: 80 88 40 02 btst %g1, %g2
40007ecc: 22 bf ff b3 be,a 40007d98 <sigtimedwait+0x78>
40007ed0: 05 10 00 6c sethi %hi(0x4001b000), %g2
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
40007ed4: 7f ff ff 7b call 40007cc0 <_POSIX_signals_Get_lowest>
40007ed8: 90 10 00 02 mov %g2, %o0
_POSIX_signals_Clear_signals(
40007edc: 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 );
40007ee0: 92 10 00 08 mov %o0, %o1
40007ee4: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
40007ee8: 96 10 20 00 clr %o3
40007eec: 90 10 00 1b mov %i3, %o0
40007ef0: 40 00 18 46 call 4000e008 <_POSIX_signals_Clear_signals>
40007ef4: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
40007ef8: 7f ff ea 36 call 400027d0 <sparc_enable_interrupts>
40007efc: 90 10 00 10 mov %l0, %o0
the_info->si_code = SI_USER;
40007f00: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
40007f04: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
40007f08: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
40007f0c: f0 06 40 00 ld [ %i1 ], %i0
40007f10: 81 c7 e0 08 ret
40007f14: 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;
40007f18: 40 00 23 6d call 40010ccc <__errno>
40007f1c: b0 10 3f ff mov -1, %i0
40007f20: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40007f24: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40007f28: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
return the_info->si_signo;
}
40007f2c: 81 c7 e0 08 ret
40007f30: 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 );
40007f34: 40 00 23 66 call 40010ccc <__errno>
40007f38: b0 10 3f ff mov -1, %i0
40007f3c: 82 10 20 16 mov 0x16, %g1
40007f40: c2 22 00 00 st %g1, [ %o0 ]
40007f44: 81 c7 e0 08 ret
40007f48: 81 e8 00 00 restore
40009b4c <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
40009b4c: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
40009b50: 92 10 20 00 clr %o1
40009b54: 90 10 00 18 mov %i0, %o0
40009b58: 7f ff ff 6e call 40009910 <sigtimedwait>
40009b5c: 94 10 20 00 clr %o2
if ( status != -1 ) {
40009b60: 80 a2 3f ff cmp %o0, -1
40009b64: 02 80 00 07 be 40009b80 <sigwait+0x34>
40009b68: 80 a6 60 00 cmp %i1, 0
if ( sig )
40009b6c: 02 80 00 0a be 40009b94 <sigwait+0x48> <== NEVER TAKEN
40009b70: 01 00 00 00 nop
*sig = status;
40009b74: d0 26 40 00 st %o0, [ %i1 ]
return 0;
40009b78: 81 c7 e0 08 ret
40009b7c: 91 e8 20 00 restore %g0, 0, %o0
}
return errno;
40009b80: 40 00 22 86 call 40012598 <__errno>
40009b84: 01 00 00 00 nop
40009b88: f0 02 00 00 ld [ %o0 ], %i0
40009b8c: 81 c7 e0 08 ret
40009b90: 81 e8 00 00 restore
}
40009b94: 81 c7 e0 08 ret <== NOT EXECUTED
40009b98: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40005ea0 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
40005ea0: 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)) {
40005ea4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40005ea8: 80 88 6e 78 btst 0xe78, %g1
40005eac: 32 80 00 04 bne,a 40005ebc <siproc+0x1c> <== ALWAYS TAKEN
40005eb0: 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);
40005eb4: 7f ff ff 64 call 40005c44 <iproc> <== NOT EXECUTED
40005eb8: 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);
40005ebc: 94 10 20 00 clr %o2
40005ec0: 40 00 05 33 call 4000738c <rtems_semaphore_obtain>
40005ec4: 92 10 20 00 clr %o1
i = iproc (c, tty);
40005ec8: 90 10 00 18 mov %i0, %o0
40005ecc: 7f ff ff 5e call 40005c44 <iproc>
40005ed0: 92 10 00 19 mov %i1, %o1
40005ed4: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
40005ed8: 40 00 05 7c call 400074c8 <rtems_semaphore_release>
40005edc: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
40005ee0: 81 c7 e0 08 ret
40005ee4: 81 e8 00 00 restore
4000eb40 <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 )
{
4000eb40: 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 ) {
4000eb44: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000eb48: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000eb4c: 80 a6 40 01 cmp %i1, %g1
4000eb50: 02 80 00 23 be 4000ebdc <sparse_disk_ioctl+0x9c>
4000eb54: 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 ) {
4000eb58: 03 08 00 10 sethi %hi(0x20004000), %g1
4000eb5c: 82 10 62 07 or %g1, 0x207, %g1 ! 20004207 <RAM_SIZE+0x1fc04207>
4000eb60: 80 a6 40 01 cmp %i1, %g1
4000eb64: 02 80 00 07 be 4000eb80 <sparse_disk_ioctl+0x40>
4000eb68: 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 );
4000eb6c: 92 10 00 19 mov %i1, %o1
4000eb70: 40 00 0c ab call 40011e1c <rtems_blkdev_ioctl>
4000eb74: 94 10 00 1a mov %i2, %o2
4000eb78: 81 c7 e0 08 ret
4000eb7c: 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 );
4000eb80: 7f ff e9 e7 call 4000931c <rtems_semaphore_delete>
4000eb84: d0 06 c0 00 ld [ %i3 ], %o0
if ( RTEMS_SUCCESSFUL != sc )
4000eb88: 80 a2 20 00 cmp %o0, 0
4000eb8c: 12 80 00 a0 bne 4000ee0c <sparse_disk_ioctl+0x2cc> <== NEVER TAKEN
4000eb90: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
4000eb94: 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;
4000eb98: c0 26 c0 00 clr [ %i3 ]
if ( NULL != sd->delete_handler )
4000eb9c: 80 a0 60 00 cmp %g1, 0
4000eba0: 02 80 00 04 be 4000ebb0 <sparse_disk_ioctl+0x70> <== NEVER TAKEN
4000eba4: b0 10 20 00 clr %i0
( *sd->delete_handler )( sd );
4000eba8: 9f c0 40 00 call %g1
4000ebac: 90 10 00 1b mov %i3, %o0
4000ebb0: 81 c7 e0 08 ret
4000ebb4: 81 e8 00 00 restore
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
4000ebb8: d0 06 c0 00 ld [ %i3 ], %o0
4000ebbc: 7f ff ea 5e call 40009534 <rtems_semaphore_release>
4000ebc0: 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);
4000ebc4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000ebc8: 90 10 00 1a mov %i2, %o0
4000ebcc: 9f c0 40 00 call %g1
4000ebd0: 92 10 20 00 clr %o1
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
return -1;
}
4000ebd4: 81 c7 e0 08 ret
4000ebd8: 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 ) {
4000ebdc: e6 06 80 00 ld [ %i2 ], %l3
4000ebe0: 80 a4 e0 01 cmp %l3, 1
4000ebe4: 18 80 00 84 bgu 4000edf4 <sparse_disk_ioctl+0x2b4> <== NEVER TAKEN
4000ebe8: 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 );
4000ebec: d0 06 c0 00 ld [ %i3 ], %o0
4000ebf0: 7f ff ea 02 call 400093f8 <rtems_semaphore_obtain>
4000ebf4: 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(
4000ebf8: 25 10 00 3a sethi %hi(0x4000e800), %l2
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
4000ebfc: 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;
4000ec00: 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(
4000ec04: a4 14 a3 18 or %l2, 0x318, %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 );
4000ec08: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000ec0c: 80 a0 40 14 cmp %g1, %l4
4000ec10: 08 bf ff ea bleu 4000ebb8 <sparse_disk_ioctl+0x78>
4000ec14: 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 ) ) {
4000ec18: 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];
4000ec1c: 86 00 e0 18 add %g3, 0x18, %g3
4000ec20: 82 06 80 03 add %i2, %g3, %g1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
4000ec24: 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;
4000ec28: e2 00 60 08 ld [ %g1 + 8 ], %l1
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
4000ec2c: 06 80 00 40 bl 4000ed2c <sparse_disk_ioctl+0x1ec> <== NEVER TAKEN
4000ec30: f8 00 60 04 ld [ %g1 + 4 ], %i4
4000ec34: 80 a7 20 00 cmp %i4, 0
4000ec38: 02 80 00 3d be 4000ed2c <sparse_disk_ioctl+0x1ec> <== NEVER TAKEN
4000ec3c: 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 = {
4000ec40: 10 80 00 1d b 4000ecb4 <sparse_disk_ioctl+0x174>
4000ec44: f2 27 bf f8 st %i1, [ %fp + -8 ]
4000ec48: 80 a7 00 01 cmp %i4, %g1
4000ec4c: 38 80 00 02 bgu,a 4000ec54 <sparse_disk_ioctl+0x114>
4000ec50: 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(
4000ec54: d2 06 e0 18 ld [ %i3 + 0x18 ], %o1
4000ec58: d4 06 e0 08 ld [ %i3 + 8 ], %o2
4000ec5c: 90 07 bf f8 add %fp, -8, %o0
4000ec60: 96 10 20 08 mov 8, %o3
4000ec64: 40 00 35 a9 call 4001c308 <bsearch>
4000ec68: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
4000ec6c: 80 a2 20 00 cmp %o0, 0
4000ec70: 02 80 00 29 be 4000ed14 <sparse_disk_ioctl+0x1d4>
4000ec74: 94 10 00 1d mov %i5, %o2
memcpy( buffer, key->data, bytes_to_copy );
4000ec78: d2 02 20 04 ld [ %o0 + 4 ], %o1
4000ec7c: 40 00 38 6a call 4001ce24 <memcpy>
4000ec80: 90 10 00 10 mov %l0, %o0
4000ec84: b8 27 00 1d sub %i4, %i5, %i4
4000ec88: 82 38 00 1d xnor %g0, %i5, %g1
4000ec8c: 80 a0 00 1c cmp %g0, %i4
4000ec90: 83 30 60 1f srl %g1, 0x1f, %g1
4000ec94: 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;
4000ec98: 84 10 00 1d mov %i5, %g2
4000ec9c: 82 08 c0 01 and %g3, %g1, %g1
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000eca0: 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 ) ) {
4000eca4: 80 88 60 ff btst 0xff, %g1
4000eca8: 02 80 00 21 be 4000ed2c <sparse_disk_ioctl+0x1ec>
4000ecac: 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 = {
4000ecb0: f2 27 bf f8 st %i1, [ %fp + -8 ]
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
4000ecb4: 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 = {
4000ecb8: 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,
4000ecbc: 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 )
4000ecc0: 80 a4 e0 00 cmp %l3, 0
4000ecc4: 02 bf ff e1 be 4000ec48 <sparse_disk_ioctl+0x108>
4000ecc8: ba 10 00 1c mov %i4, %i5
4000eccc: 80 a7 00 01 cmp %i4, %g1
4000ecd0: 38 80 00 02 bgu,a 4000ecd8 <sparse_disk_ioctl+0x198>
4000ecd4: 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(
4000ecd8: d2 06 e0 18 ld [ %i3 + 0x18 ], %o1
4000ecdc: d4 06 e0 08 ld [ %i3 + 8 ], %o2
4000ece0: 90 07 bf f8 add %fp, -8, %o0
4000ece4: 96 10 20 08 mov 8, %o3
4000ece8: 40 00 35 88 call 4001c308 <bsearch>
4000ecec: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
4000ecf0: aa 92 20 00 orcc %o0, 0, %l5
4000ecf4: 02 80 00 1a be 4000ed5c <sparse_disk_ioctl+0x21c>
4000ecf8: 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 );
4000ecfc: d0 05 60 04 ld [ %l5 + 4 ], %o0
4000ed00: 92 10 00 10 mov %l0, %o1
4000ed04: 40 00 38 48 call 4001ce24 <memcpy>
4000ed08: 94 10 00 1d mov %i5, %o2
4000ed0c: 10 bf ff df b 4000ec88 <sparse_disk_ioctl+0x148>
4000ed10: 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 );
4000ed14: d2 0e e0 14 ldub [ %i3 + 0x14 ], %o1
4000ed18: 90 10 00 10 mov %l0, %o0
4000ed1c: 40 00 38 7f call 4001cf18 <memset>
4000ed20: 94 10 00 1c mov %i4, %o2
4000ed24: 10 bf ff d9 b 4000ec88 <sparse_disk_ioctl+0x148>
4000ed28: 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;
4000ed2c: 80 a0 a0 00 cmp %g2, 0
4000ed30: 16 bf ff b6 bge 4000ec08 <sparse_disk_ioctl+0xc8> <== ALWAYS TAKEN
4000ed34: a8 05 20 01 inc %l4
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
4000ed38: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
4000ed3c: 7f ff e9 fe call 40009534 <rtems_semaphore_release> <== NOT EXECUTED
4000ed40: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000ed44: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
4000ed48: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000ed4c: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000ed50: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
4000ed54: 81 c7 e0 08 ret <== NOT EXECUTED
4000ed58: 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 ) {
4000ed5c: 02 bf ff ca be 4000ec84 <sparse_disk_ioctl+0x144> <== NEVER TAKEN
4000ed60: 82 10 20 00 clr %g1
4000ed64: 10 80 00 05 b 4000ed78 <sparse_disk_ioctl+0x238>
4000ed68: c8 0e e0 14 ldub [ %i3 + 0x14 ], %g4
4000ed6c: 80 a0 40 1d cmp %g1, %i5
4000ed70: 1a 80 00 0b bcc 4000ed9c <sparse_disk_ioctl+0x25c>
4000ed74: 80 88 e0 ff btst 0xff, %g3
if ( buffer[i] != sparse_disk->fill_pattern )
4000ed78: 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 ) {
4000ed7c: 82 00 60 01 inc %g1
if ( buffer[i] != sparse_disk->fill_pattern )
4000ed80: 84 18 80 04 xor %g2, %g4, %g2
4000ed84: 80 a0 00 02 cmp %g0, %g2
4000ed88: 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 ) {
4000ed8c: 80 a0 a0 00 cmp %g2, 0
4000ed90: 02 bf ff f7 be 4000ed6c <sparse_disk_ioctl+0x22c>
4000ed94: 86 10 00 02 mov %g2, %g3
if ( buffer[i] != sparse_disk->fill_pattern )
block_needs_writing = true;
}
if ( block_needs_writing ) {
4000ed98: 80 88 e0 ff btst 0xff, %g3
4000ed9c: 22 bf ff bb be,a 4000ec88 <sparse_disk_ioctl+0x148>
4000eda0: 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 ) {
4000eda4: c2 06 e0 08 ld [ %i3 + 8 ], %g1
4000eda8: c4 06 e0 04 ld [ %i3 + 4 ], %g2
4000edac: 80 a0 40 02 cmp %g1, %g2
4000edb0: 1a 80 00 0c bcc 4000ede0 <sparse_disk_ioctl+0x2a0> <== NEVER TAKEN
4000edb4: ab 28 60 03 sll %g1, 3, %l5
key = &sparse_disk->key_table[sparse_disk->used_count];
4000edb8: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0
key->block = block;
4000edbc: f2 22 00 15 st %i1, [ %o0 + %l5 ]
++sparse_disk->used_count;
4000edc0: 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];
4000edc4: aa 02 00 15 add %o0, %l5, %l5
key->block = block;
++sparse_disk->used_count;
4000edc8: d2 26 e0 08 st %o1, [ %i3 + 8 ]
qsort( sparse_disk->key_table, sparse_disk->used_count,
4000edcc: 94 10 20 08 mov 8, %o2
4000edd0: 40 00 38 98 call 4001d030 <qsort>
4000edd4: 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 );
4000edd8: 10 bf ff ca b 4000ed00 <sparse_disk_ioctl+0x1c0>
4000eddc: d0 05 60 04 ld [ %l5 + 4 ], %o0
4000ede0: 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 ) {
4000ede4: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000ede8: 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;
4000edec: 10 bf ff ad b 4000eca0 <sparse_disk_ioctl+0x160> <== NOT EXECUTED
4000edf0: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
4000edf4: 40 00 35 67 call 4001c390 <__errno> <== NOT EXECUTED
4000edf8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000edfc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000ee00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
4000ee04: 81 c7 e0 08 ret <== NOT EXECUTED
4000ee08: 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 );
4000ee0c: 7f ff eb 5c call 40009b7c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000ee10: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40005574 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
40005574: 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;
40005578: c2 06 21 48 ld [ %i0 + 0x148 ], %g1
if ( this_reent ) {
4000557c: 80 a0 60 00 cmp %g1, 0
40005580: 02 80 00 0c be 400055b0 <sync_per_thread+0x3c> <== NEVER TAKEN
40005584: 3b 10 00 62 sethi %hi(0x40018800), %i5
current_reent = _Thread_Executing->libc_reent;
40005588: ba 17 61 e0 or %i5, 0x1e0, %i5 ! 400189e0 <_Per_CPU_Information>
4000558c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
40005590: 13 10 00 15 sethi %hi(0x40005400), %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;
40005594: f8 00 a1 48 ld [ %g2 + 0x148 ], %i4
_Thread_Executing->libc_reent = this_reent;
40005598: c2 20 a1 48 st %g1, [ %g2 + 0x148 ]
_fwalk (t->libc_reent, sync_wrapper);
4000559c: d0 06 21 48 ld [ %i0 + 0x148 ], %o0
400055a0: 40 00 2e eb call 4001114c <_fwalk>
400055a4: 92 12 61 b8 or %o1, 0x1b8, %o1
_Thread_Executing->libc_reent = current_reent;
400055a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400055ac: f8 20 61 48 st %i4, [ %g1 + 0x148 ]
400055b0: 81 c7 e0 08 ret
400055b4: 81 e8 00 00 restore
400069c8 <sysconf>:
*/
long sysconf(
int name
)
{
400069c8: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
400069cc: 80 a6 20 02 cmp %i0, 2
400069d0: 02 80 00 12 be 40006a18 <sysconf+0x50>
400069d4: 82 10 00 18 mov %i0, %g1
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
400069d8: 80 a6 20 04 cmp %i0, 4
400069dc: 02 80 00 16 be 40006a34 <sysconf+0x6c>
400069e0: 80 a0 60 33 cmp %g1, 0x33
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
400069e4: 02 80 00 0b be 40006a10 <sysconf+0x48>
400069e8: b0 10 24 00 mov 0x400, %i0
return 1024;
if ( name == _SC_PAGESIZE )
400069ec: 80 a0 60 08 cmp %g1, 8
400069f0: 02 80 00 08 be 40006a10 <sysconf+0x48>
400069f4: 31 00 00 04 sethi %hi(0x1000), %i0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
400069f8: 80 a0 60 4f cmp %g1, 0x4f
400069fc: 02 80 00 05 be 40006a10 <sysconf+0x48> <== NEVER TAKEN
40006a00: b0 10 20 20 mov 0x20, %i0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
40006a04: 80 a0 62 03 cmp %g1, 0x203
40006a08: 12 80 00 0f bne 40006a44 <sysconf+0x7c> <== ALWAYS TAKEN
40006a0c: b0 10 20 00 clr %i0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
40006a10: 81 c7 e0 08 ret
40006a14: 81 e8 00 00 restore
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
40006a18: 03 10 00 56 sethi %hi(0x40015800), %g1
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
40006a1c: d2 00 60 b4 ld [ %g1 + 0xb4 ], %o1 ! 400158b4 <Configuration+0xc>
40006a20: 11 00 03 d0 sethi %hi(0xf4000), %o0
40006a24: 40 00 32 7c call 40013414 <.udiv>
40006a28: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
40006a2c: 81 c7 e0 08 ret
40006a30: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
40006a34: 03 10 00 5c sethi %hi(0x40017000), %g1
40006a38: f0 00 60 e8 ld [ %g1 + 0xe8 ], %i0 ! 400170e8 <rtems_libio_number_iops>
40006a3c: 81 c7 e0 08 ret
40006a40: 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 );
40006a44: 40 00 23 23 call 4000f6d0 <__errno>
40006a48: b0 10 3f ff mov -1, %i0
40006a4c: 82 10 20 16 mov 0x16, %g1
40006a50: c2 22 00 00 st %g1, [ %o0 ]
}
40006a54: 81 c7 e0 08 ret
40006a58: 81 e8 00 00 restore
40015c50 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
40015c50: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
40015c54: 80 a6 60 00 cmp %i1, 0
40015c58: 02 80 00 10 be 40015c98 <tcsetattr+0x48>
40015c5c: 80 a6 60 01 cmp %i1, 1
40015c60: 02 80 00 08 be 40015c80 <tcsetattr+0x30>
40015c64: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
40015c68: 40 00 12 20 call 4001a4e8 <__errno>
40015c6c: 01 00 00 00 nop
40015c70: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
40015c74: c2 22 00 00 st %g1, [ %o0 ]
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
40015c78: 81 c7 e0 08 ret
40015c7c: 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)
40015c80: 92 10 20 03 mov 3, %o1
40015c84: 40 00 0e 82 call 4001968c <ioctl>
40015c88: 94 10 20 00 clr %o2
40015c8c: 80 a2 20 00 cmp %o0, 0
40015c90: 06 bf ff fa bl 40015c78 <tcsetattr+0x28> <== NEVER TAKEN
40015c94: 01 00 00 00 nop
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
40015c98: 40 00 0e 7d call 4001968c <ioctl>
40015c9c: 93 e8 20 02 restore %g0, 2, %o1
40008250 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
40008250: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
40008254: 80 a6 20 01 cmp %i0, 1
40008258: 12 80 00 3d bne 4000834c <timer_create+0xfc>
4000825c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
40008260: 02 80 00 3b be 4000834c <timer_create+0xfc>
40008264: 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) {
40008268: 02 80 00 0e be 400082a0 <timer_create+0x50>
4000826c: 03 10 00 8e sethi %hi(0x40023800), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
40008270: c2 06 40 00 ld [ %i1 ], %g1
40008274: 82 00 7f ff add %g1, -1, %g1
40008278: 80 a0 60 01 cmp %g1, 1
4000827c: 18 80 00 34 bgu 4000834c <timer_create+0xfc> <== NEVER TAKEN
40008280: 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 )
40008284: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008288: 80 a0 60 00 cmp %g1, 0
4000828c: 02 80 00 30 be 4000834c <timer_create+0xfc> <== NEVER TAKEN
40008290: 82 00 7f ff add %g1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
40008294: 80 a0 60 1f cmp %g1, 0x1f
40008298: 18 80 00 2d bgu 4000834c <timer_create+0xfc> <== NEVER TAKEN
4000829c: 03 10 00 8e sethi %hi(0x40023800), %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;
400082a0: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 400238c0 <_Thread_Dispatch_disable_level>
++level;
400082a4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400082a8: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ]
* 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 );
400082ac: 3b 10 00 8e sethi %hi(0x40023800), %i5
400082b0: 40 00 08 e0 call 4000a630 <_Objects_Allocate>
400082b4: 90 17 63 c4 or %i5, 0x3c4, %o0 ! 40023bc4 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
400082b8: 80 a2 20 00 cmp %o0, 0
400082bc: 02 80 00 2a be 40008364 <timer_create+0x114>
400082c0: 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;
400082c4: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
400082c8: 03 10 00 8f sethi %hi(0x40023c00), %g1
400082cc: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 40023e20 <_Per_CPU_Information+0x10>
if ( evp != NULL ) {
400082d0: 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;
400082d4: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
400082d8: 02 80 00 08 be 400082f8 <timer_create+0xa8>
400082dc: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
400082e0: c6 06 40 00 ld [ %i1 ], %g3
ptimer->inf.sigev_signo = evp->sigev_signo;
400082e4: c4 06 60 04 ld [ %i1 + 4 ], %g2
ptimer->inf.sigev_value = evp->sigev_value;
400082e8: 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;
400082ec: c6 22 20 40 st %g3, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
400082f0: c4 22 20 44 st %g2, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
400082f4: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400082f8: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400082fc: ba 17 63 c4 or %i5, 0x3c4, %i5
40008300: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
}
ptimer->overrun = 0;
40008304: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
40008308: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
4000830c: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
40008310: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
40008314: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40008318: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
4000831c: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
40008320: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
40008324: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008328: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000832c: 85 28 a0 02 sll %g2, 2, %g2
40008330: 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;
40008334: 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;
40008338: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
4000833c: 40 00 0e 09 call 4000bb60 <_Thread_Enable_dispatch>
40008340: b0 10 20 00 clr %i0
return 0;
}
40008344: 81 c7 e0 08 ret
40008348: 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 );
4000834c: 40 00 24 c4 call 4001165c <__errno>
40008350: b0 10 3f ff mov -1, %i0
40008354: 82 10 20 16 mov 0x16, %g1
40008358: c2 22 00 00 st %g1, [ %o0 ]
4000835c: 81 c7 e0 08 ret
40008360: 81 e8 00 00 restore
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
40008364: 40 00 0d ff call 4000bb60 <_Thread_Enable_dispatch>
40008368: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
4000836c: 40 00 24 bc call 4001165c <__errno>
40008370: 01 00 00 00 nop
40008374: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
40008378: c2 22 00 00 st %g1, [ %o0 ]
4000837c: 81 c7 e0 08 ret
40008380: 81 e8 00 00 restore
40006ea8 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
40006ea8: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
40006eac: 80 a6 a0 00 cmp %i2, 0
40006eb0: 02 80 00 86 be 400070c8 <timer_settime+0x220> <== NEVER TAKEN
40006eb4: 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) ) ) {
40006eb8: 40 00 10 37 call 4000af94 <_Timespec_Is_valid>
40006ebc: 90 06 a0 08 add %i2, 8, %o0
40006ec0: 80 8a 20 ff btst 0xff, %o0
40006ec4: 02 80 00 81 be 400070c8 <timer_settime+0x220>
40006ec8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
40006ecc: 40 00 10 32 call 4000af94 <_Timespec_Is_valid>
40006ed0: 90 10 00 1a mov %i2, %o0
40006ed4: 80 8a 20 ff btst 0xff, %o0
40006ed8: 02 80 00 7c be 400070c8 <timer_settime+0x220> <== NEVER TAKEN
40006edc: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
40006ee0: 12 80 00 7a bne 400070c8 <timer_settime+0x220>
40006ee4: 80 a6 60 04 cmp %i1, 4
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
40006ee8: c8 06 80 00 ld [ %i2 ], %g4
40006eec: c6 06 a0 04 ld [ %i2 + 4 ], %g3
40006ef0: c4 06 a0 08 ld [ %i2 + 8 ], %g2
40006ef4: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
40006ef8: c8 27 bf f0 st %g4, [ %fp + -16 ]
40006efc: c6 27 bf f4 st %g3, [ %fp + -12 ]
40006f00: c4 27 bf f8 st %g2, [ %fp + -8 ]
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
40006f04: 02 80 00 4c be 40007034 <timer_settime+0x18c>
40006f08: 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 *)
40006f0c: 92 10 00 18 mov %i0, %o1
40006f10: 11 10 00 7f sethi %hi(0x4001fc00), %o0
40006f14: 94 07 bf dc add %fp, -36, %o2
40006f18: 40 00 09 ba call 40009600 <_Objects_Get>
40006f1c: 90 12 20 d4 or %o0, 0xd4, %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 ) {
40006f20: c2 07 bf dc ld [ %fp + -36 ], %g1
40006f24: 80 a0 60 00 cmp %g1, 0
40006f28: 12 80 00 68 bne 400070c8 <timer_settime+0x220> <== NEVER TAKEN
40006f2c: 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 ) {
40006f30: c2 07 bf f8 ld [ %fp + -8 ], %g1
40006f34: 80 a0 60 00 cmp %g1, 0
40006f38: 12 80 00 05 bne 40006f4c <timer_settime+0xa4>
40006f3c: c2 07 bf fc ld [ %fp + -4 ], %g1
40006f40: 80 a0 60 00 cmp %g1, 0
40006f44: 02 80 00 67 be 400070e0 <timer_settime+0x238>
40006f48: 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 );
40006f4c: 40 00 10 4b call 4000b078 <_Timespec_To_ticks>
40006f50: 90 10 00 1a mov %i2, %o0
40006f54: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
40006f58: 40 00 10 48 call 4000b078 <_Timespec_To_ticks>
40006f5c: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
40006f60: 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 );
40006f64: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
40006f68: 98 10 00 19 mov %i1, %o4
40006f6c: 90 06 60 10 add %i1, 0x10, %o0
40006f70: 17 10 00 1c sethi %hi(0x40007000), %o3
40006f74: 40 00 19 c7 call 4000d690 <_POSIX_Timer_Insert_helper>
40006f78: 96 12 e1 4c or %o3, 0x14c, %o3 ! 4000714c <_POSIX_Timer_TSR>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
40006f7c: 80 8a 20 ff btst 0xff, %o0
40006f80: 02 80 00 29 be 40007024 <timer_settime+0x17c>
40006f84: 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 )
40006f88: 02 80 00 0b be 40006fb4 <timer_settime+0x10c>
40006f8c: c2 07 bf f0 ld [ %fp + -16 ], %g1
*ovalue = ptimer->timer_data;
40006f90: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
40006f94: c2 26 c0 00 st %g1, [ %i3 ]
40006f98: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
40006f9c: c2 26 e0 04 st %g1, [ %i3 + 4 ]
40006fa0: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
40006fa4: c2 26 e0 08 st %g1, [ %i3 + 8 ]
40006fa8: c2 06 60 60 ld [ %i1 + 0x60 ], %g1
40006fac: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
ptimer->timer_data = normalize;
40006fb0: c2 07 bf f0 ld [ %fp + -16 ], %g1
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40006fb4: 90 07 bf e0 add %fp, -32, %o0
40006fb8: c2 26 60 54 st %g1, [ %i1 + 0x54 ]
40006fbc: c2 07 bf f4 ld [ %fp + -12 ], %g1
40006fc0: 13 10 00 7e sethi %hi(0x4001f800), %o1
40006fc4: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
40006fc8: c2 07 bf f8 ld [ %fp + -8 ], %g1
40006fcc: 92 12 61 58 or %o1, 0x158, %o1
40006fd0: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
40006fd4: c2 07 bf fc ld [ %fp + -4 ], %g1
40006fd8: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
40006fdc: 82 10 20 03 mov 3, %g1
40006fe0: 40 00 06 b4 call 40008ab0 <_TOD_Get_with_nanoseconds>
40006fe4: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40006fe8: 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);
40006fec: 94 10 20 00 clr %o2
40006ff0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40006ff4: 90 10 00 1c mov %i4, %o0
40006ff8: 96 12 e2 00 or %o3, 0x200, %o3
40006ffc: 40 00 4a ad call 40019ab0 <__divdi3>
40007000: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007004: 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);
40007008: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
4000700c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007010: 90 10 00 1c mov %i4, %o0
40007014: 96 12 e2 00 or %o3, 0x200, %o3
40007018: 40 00 4b 91 call 40019e5c <__moddi3>
4000701c: 92 10 00 1d mov %i5, %o1
40007020: 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();
40007024: 40 00 0d 2e call 4000a4dc <_Thread_Enable_dispatch>
40007028: b0 10 20 00 clr %i0
4000702c: 81 c7 e0 08 ret
40007030: 81 e8 00 00 restore
40007034: 90 07 bf e0 add %fp, -32, %o0
40007038: 13 10 00 7e sethi %hi(0x4001f800), %o1
4000703c: 40 00 06 9d call 40008ab0 <_TOD_Get_with_nanoseconds>
40007040: 92 12 61 58 or %o1, 0x158, %o1 ! 4001f958 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40007044: 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);
40007048: 94 10 20 00 clr %o2
4000704c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007050: 90 10 00 1c mov %i4, %o0
40007054: 96 12 e2 00 or %o3, 0x200, %o3
40007058: 40 00 4a 96 call 40019ab0 <__divdi3>
4000705c: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007060: 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);
40007064: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007068: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4000706c: 90 10 00 1c mov %i4, %o0
40007070: 96 12 e2 00 or %o3, 0x200, %o3
40007074: 40 00 4b 7a call 40019e5c <__moddi3>
40007078: 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 ) )
4000707c: 90 07 bf f8 add %fp, -8, %o0
40007080: d2 27 bf ec st %o1, [ %fp + -20 ]
40007084: 40 00 0f d7 call 4000afe0 <_Timespec_Less_than>
40007088: 92 07 bf e8 add %fp, -24, %o1
4000708c: 80 8a 20 ff btst 0xff, %o0
40007090: 12 80 00 0e bne 400070c8 <timer_settime+0x220>
40007094: 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 );
40007098: 90 07 bf e8 add %fp, -24, %o0
4000709c: 40 00 0f e3 call 4000b028 <_Timespec_Subtract>
400070a0: 94 10 00 09 mov %o1, %o2
400070a4: 92 10 00 18 mov %i0, %o1
400070a8: 11 10 00 7f sethi %hi(0x4001fc00), %o0
400070ac: 94 07 bf dc add %fp, -36, %o2
400070b0: 40 00 09 54 call 40009600 <_Objects_Get>
400070b4: 90 12 20 d4 or %o0, 0xd4, %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 ) {
400070b8: c2 07 bf dc ld [ %fp + -36 ], %g1
400070bc: 80 a0 60 00 cmp %g1, 0
400070c0: 02 bf ff 9c be 40006f30 <timer_settime+0x88>
400070c4: b2 10 00 08 mov %o0, %i1
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
400070c8: 40 00 24 11 call 4001010c <__errno>
400070cc: b0 10 3f ff mov -1, %i0
400070d0: 82 10 20 16 mov 0x16, %g1
400070d4: c2 22 00 00 st %g1, [ %o0 ]
}
400070d8: 81 c7 e0 08 ret
400070dc: 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 );
400070e0: 40 00 10 ef call 4000b49c <_Watchdog_Remove>
400070e4: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
400070e8: 80 a6 e0 00 cmp %i3, 0
400070ec: 02 80 00 0b be 40007118 <timer_settime+0x270>
400070f0: c2 07 bf f0 ld [ %fp + -16 ], %g1
*ovalue = ptimer->timer_data;
400070f4: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
400070f8: c2 26 c0 00 st %g1, [ %i3 ]
400070fc: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
40007100: c2 26 e0 04 st %g1, [ %i3 + 4 ]
40007104: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
40007108: c2 26 e0 08 st %g1, [ %i3 + 8 ]
4000710c: c2 06 60 60 ld [ %i1 + 0x60 ], %g1
40007110: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
/* The new data are set */
ptimer->timer_data = normalize;
40007114: 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;
40007118: 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;
4000711c: c2 26 60 54 st %g1, [ %i1 + 0x54 ]
40007120: c2 07 bf f4 ld [ %fp + -12 ], %g1
40007124: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
40007128: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000712c: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
40007130: c2 07 bf fc ld [ %fp + -4 ], %g1
40007134: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
40007138: 82 10 20 04 mov 4, %g1
/* Returns with success */
_Thread_Enable_dispatch();
4000713c: 40 00 0c e8 call 4000a4dc <_Thread_Enable_dispatch>
40007140: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
40007144: 81 c7 e0 08 ret
40007148: 81 e8 00 00 restore
40006df4 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
40006df4: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
40006df8: 3b 10 00 65 sethi %hi(0x40019400), %i5
40006dfc: ba 17 62 58 or %i5, 0x258, %i5 ! 40019658 <_POSIX_signals_Ualarm_timer>
40006e00: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40006e04: 80 a0 60 00 cmp %g1, 0
40006e08: 02 80 00 24 be 40006e98 <ualarm+0xa4>
40006e0c: 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 );
40006e10: 40 00 10 8e call 4000b048 <_Watchdog_Remove>
40006e14: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
40006e18: 90 02 3f fe add %o0, -2, %o0
40006e1c: 80 a2 20 01 cmp %o0, 1
40006e20: 08 80 00 26 bleu 40006eb8 <ualarm+0xc4> <== ALWAYS TAKEN
40006e24: 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 ) {
40006e28: 80 a7 20 00 cmp %i4, 0
40006e2c: 02 80 00 19 be 40006e90 <ualarm+0x9c>
40006e30: 37 00 03 d0 sethi %hi(0xf4000), %i3
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
40006e34: 90 10 00 1c mov %i4, %o0
40006e38: 40 00 37 2b call 40014ae4 <.udiv>
40006e3c: 92 16 e2 40 or %i3, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40006e40: 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;
40006e44: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40006e48: 40 00 37 d3 call 40014d94 <.urem>
40006e4c: 90 10 00 1c mov %i4, %o0
40006e50: 87 2a 20 07 sll %o0, 7, %g3
40006e54: 82 10 00 08 mov %o0, %g1
40006e58: 85 2a 20 02 sll %o0, 2, %g2
40006e5c: 84 20 c0 02 sub %g3, %g2, %g2
40006e60: 82 00 80 01 add %g2, %g1, %g1
40006e64: 83 28 60 03 sll %g1, 3, %g1
ticks = _Timespec_To_ticks( &tp );
40006e68: 90 07 bf f8 add %fp, -8, %o0
40006e6c: 40 00 0f 3e call 4000ab64 <_Timespec_To_ticks>
40006e70: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
40006e74: 40 00 0f 3c call 4000ab64 <_Timespec_To_ticks>
40006e78: 90 07 bf f8 add %fp, -8, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006e7c: 92 10 00 1d mov %i5, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006e80: d0 27 60 0c st %o0, [ %i5 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006e84: 11 10 00 63 sethi %hi(0x40018c00), %o0
40006e88: 40 00 10 11 call 4000aecc <_Watchdog_Insert>
40006e8c: 90 12 22 08 or %o0, 0x208, %o0 ! 40018e08 <_Watchdog_Ticks_chain>
}
return remaining;
}
40006e90: 81 c7 e0 08 ret
40006e94: 81 e8 00 00 restore
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40006e98: 03 10 00 1b sethi %hi(0x40006c00), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40006e9c: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
40006ea0: 82 10 61 c4 or %g1, 0x1c4, %g1
the_watchdog->id = id;
40006ea4: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40006ea8: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40006eac: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
40006eb0: 10 bf ff de b 40006e28 <ualarm+0x34>
40006eb4: 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);
40006eb8: c4 07 60 0c ld [ %i5 + 0xc ], %g2
40006ebc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40006ec0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
40006ec4: 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);
40006ec8: 90 02 00 02 add %o0, %g2, %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
40006ecc: 40 00 0f 11 call 4000ab10 <_Timespec_From_ticks>
40006ed0: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
40006ed4: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
40006ed8: 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;
40006edc: 85 28 60 03 sll %g1, 3, %g2
40006ee0: 87 28 60 08 sll %g1, 8, %g3
40006ee4: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
40006ee8: 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;
40006eec: b1 28 a0 06 sll %g2, 6, %i0
40006ef0: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
40006ef4: 40 00 36 fe call 40014aec <.div>
40006ef8: 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;
40006efc: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
40006f00: 10 bf ff ca b 40006e28 <ualarm+0x34>
40006f04: b0 02 00 18 add %o0, %i0, %i0
4000688c <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 )
{
4000688c: 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 =
40006890: 94 10 20 18 mov 0x18, %o2
40006894: 92 10 00 18 mov %i0, %o1
40006898: 7f ff f6 a6 call 40004330 <rtems_filesystem_eval_path_start>
4000689c: 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;
400068a0: 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)(
400068a4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400068a8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400068ac: 9f c0 40 00 call %g1
400068b0: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
400068b4: 80 8a 20 ff btst 0xff, %o0
400068b8: 02 80 00 33 be 40006984 <unmount+0xf8>
400068bc: 03 10 00 59 sethi %hi(0x40016400), %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;
400068c0: c2 00 62 1c ld [ %g1 + 0x21c ], %g1 ! 4001661c <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;
400068c4: 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;
400068c8: c6 00 40 00 ld [ %g1 ], %g3
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
400068cc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400068d0: 80 a7 40 01 cmp %i5, %g1
400068d4: 02 80 00 27 be 40006970 <unmount+0xe4>
400068d8: 01 00 00 00 nop
400068dc: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1
400068e0: 80 a7 40 01 cmp %i5, %g1
400068e4: 02 80 00 23 be 40006970 <unmount+0xe4>
400068e8: 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;
400068ec: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
400068f0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
400068f4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400068f8: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
400068fc: 9f c0 40 00 call %g1
40006900: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40006904: b0 92 20 00 orcc %o0, 0, %i0
40006908: 02 80 00 06 be 40006920 <unmount+0x94>
4000690c: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40006910: 7f ff f6 c8 call 40004430 <rtems_filesystem_eval_path_cleanup>
40006914: 90 07 bf c8 add %fp, -56, %o0
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
40006918: 81 c7 e0 08 ret
4000691c: 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();
40006920: 40 00 04 48 call 40007a40 <rtems_task_self>
40006924: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
40006928: 7f ff ed c9 call 4000204c <sparc_disable_interrupts>
4000692c: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
40006930: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
40006934: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
40006938: 7f ff ed c9 call 4000205c <sparc_enable_interrupts>
4000693c: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40006940: 7f ff f6 bc call 40004430 <rtems_filesystem_eval_path_cleanup>
40006944: 90 07 bf c8 add %fp, -56, %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40006948: 11 20 00 00 sethi %hi(0x80000000), %o0
4000694c: 92 10 20 00 clr %o1
40006950: 94 10 20 00 clr %o2
40006954: 40 00 03 78 call 40007734 <rtems_event_system_receive>
40006958: 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 ) {
4000695c: 80 a2 20 00 cmp %o0, 0
40006960: 02 bf ff ee be 40006918 <unmount+0x8c> <== ALWAYS TAKEN
40006964: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
40006968: 40 00 04 da call 40007cd0 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000696c: 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;
40006970: 40 00 23 b0 call 4000f830 <__errno>
40006974: b0 10 3f ff mov -1, %i0
40006978: 82 10 20 10 mov 0x10, %g1
4000697c: 10 bf ff e5 b 40006910 <unmount+0x84>
40006980: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
} else {
errno = EACCES;
40006984: 40 00 23 ab call 4000f830 <__errno>
40006988: b0 10 3f ff mov -1, %i0
4000698c: 82 10 20 0d mov 0xd, %g1
40006990: 10 bf ff e0 b 40006910 <unmount+0x84>
40006994: c2 22 00 00 st %g1, [ %o0 ]
40006868 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
40006868: 9d e3 bf 88 save %sp, -120, %sp
for (; *fmt != '\0'; fmt++) {
4000686c: 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(
40006870: a0 07 bf e8 add %fp, -24, %l0
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40006874: 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(
40006878: a2 07 bf e7 add %fp, -25, %l1
4000687c: 25 10 00 73 sethi %hi(0x4001cc00), %l2
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40006880: 80 a2 20 00 cmp %o0, 0
40006884: 02 80 00 74 be 40006a54 <vprintk+0x1ec> <== NEVER TAKEN
40006888: 27 10 00 71 sethi %hi(0x4001c400), %l3
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
4000688c: 91 3a 20 18 sra %o0, 0x18, %o0
40006890: 80 a2 20 25 cmp %o0, 0x25
40006894: 12 80 00 7a bne 40006a7c <vprintk+0x214>
40006898: 01 00 00 00 nop
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
4000689c: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
400068a0: 85 28 60 18 sll %g1, 0x18, %g2
400068a4: 87 38 a0 18 sra %g2, 0x18, %g3
400068a8: 80 a0 e0 30 cmp %g3, 0x30
400068ac: 22 80 00 a9 be,a 40006b50 <vprintk+0x2e8>
400068b0: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
if (*fmt != '%') {
rtems_putc(*fmt);
continue;
}
fmt++;
400068b4: b0 06 20 01 inc %i0
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
400068b8: a8 10 20 20 mov 0x20, %l4
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
400068bc: 87 38 a0 18 sra %g2, 0x18, %g3
400068c0: 80 a0 e0 2d cmp %g3, 0x2d
400068c4: 02 80 00 9e be 40006b3c <vprintk+0x2d4>
400068c8: 88 10 20 00 clr %g4
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
400068cc: 86 00 7f d0 add %g1, -48, %g3
400068d0: 86 08 e0 ff and %g3, 0xff, %g3
400068d4: 80 a0 e0 09 cmp %g3, 9
400068d8: 18 80 00 0f bgu 40006914 <vprintk+0xac>
400068dc: ba 10 20 00 clr %i5
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
400068e0: b0 06 20 01 inc %i0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
400068e4: c2 0e 00 00 ldub [ %i0 ], %g1
width *= 10;
400068e8: 87 2f 60 01 sll %i5, 1, %g3
width += ((unsigned) *fmt - '0');
400068ec: 85 38 a0 18 sra %g2, 0x18, %g2
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
400068f0: bb 2f 60 03 sll %i5, 3, %i5
400068f4: ba 00 c0 1d add %g3, %i5, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
400068f8: 86 00 7f d0 add %g1, -48, %g3
width *= 10;
width += ((unsigned) *fmt - '0');
400068fc: ba 07 40 02 add %i5, %g2, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40006900: 86 08 e0 ff and %g3, 0xff, %g3
width *= 10;
width += ((unsigned) *fmt - '0');
40006904: ba 07 7f d0 add %i5, -48, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40006908: 80 a0 e0 09 cmp %g3, 9
4000690c: 08 bf ff f5 bleu 400068e0 <vprintk+0x78>
40006910: 85 28 60 18 sll %g1, 0x18, %g2
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
40006914: 87 38 a0 18 sra %g2, 0x18, %g3
40006918: 80 a0 e0 6c cmp %g3, 0x6c
4000691c: 02 80 00 77 be 40006af8 <vprintk+0x290>
40006920: 91 38 a0 18 sra %g2, 0x18, %o0
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
40006924: 80 a2 20 63 cmp %o0, 0x63
40006928: 22 80 00 7b be,a 40006b14 <vprintk+0x2ac>
4000692c: 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' ) {
40006930: 80 a2 20 73 cmp %o0, 0x73
40006934: 02 80 00 8b be 40006b60 <vprintk+0x2f8>
40006938: 82 08 7f df and %g1, -33, %g1
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
4000693c: 83 28 60 18 sll %g1, 0x18, %g1
40006940: 83 38 60 18 sra %g1, 0x18, %g1
40006944: 80 a0 60 4f cmp %g1, 0x4f
40006948: 22 80 00 55 be,a 40006a9c <vprintk+0x234>
4000694c: f4 06 40 00 ld [ %i1 ], %i2
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
40006950: 80 a0 60 49 cmp %g1, 0x49
40006954: 22 80 00 06 be,a 4000696c <vprintk+0x104>
40006958: 82 10 20 01 mov 1, %g1
c == 'd' || c == 'D' ) {
4000695c: 80 a0 60 44 cmp %g1, 0x44
40006960: 12 80 00 3f bne 40006a5c <vprintk+0x1f4>
40006964: 80 a0 60 55 cmp %g1, 0x55
base = 10; sign = true;
40006968: 82 10 20 01 mov 1, %g1
4000696c: aa 10 20 0a mov 0xa, %l5
} else {
rtems_putc(c);
continue;
}
printNum(
40006970: f4 06 40 00 ld [ %i1 ], %i2
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
40006974: 80 a6 a0 00 cmp %i2, 0
40006978: 06 80 00 4e bl 40006ab0 <vprintk+0x248>
4000697c: b2 06 60 04 add %i1, 4, %i1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
40006980: 90 10 00 1a mov %i2, %o0
40006984: 40 00 47 bc call 40018874 <.udiv>
40006988: 92 10 00 15 mov %l5, %o1
4000698c: b8 92 20 00 orcc %o0, 0, %i4
40006990: 22 80 00 57 be,a 40006aec <vprintk+0x284>
40006994: b8 10 00 1a mov %i2, %i4
40006998: ac 10 00 15 mov %l5, %l6
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
4000699c: 10 80 00 03 b 400069a8 <vprintk+0x140>
400069a0: b6 10 20 00 clr %i3
while ((n = unsigned_num / base) > 0) {
400069a4: b8 10 00 08 mov %o0, %i4
toPrint[count++] = (char) (unsigned_num - (n * base));
400069a8: 92 10 00 1c mov %i4, %o1
400069ac: 40 00 47 78 call 4001878c <.umul>
400069b0: 90 10 00 16 mov %l6, %o0
400069b4: b4 26 80 08 sub %i2, %o0, %i2
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
400069b8: 92 10 00 15 mov %l5, %o1
toPrint[count++] = (char) (unsigned_num - (n * base));
400069bc: f4 2c 00 1b stb %i2, [ %l0 + %i3 ]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
400069c0: 90 10 00 1c mov %i4, %o0
400069c4: 40 00 47 ac call 40018874 <.udiv>
400069c8: b4 10 00 1c mov %i4, %i2
400069cc: 80 a2 20 00 cmp %o0, 0
400069d0: 12 bf ff f5 bne 400069a4 <vprintk+0x13c>
400069d4: b6 06 e0 01 inc %i3
400069d8: b4 06 e0 01 add %i3, 1, %i2
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
400069dc: b6 07 80 1b add %fp, %i3, %i3
400069e0: f8 2e ff e8 stb %i4, [ %i3 + -24 ]
400069e4: a9 2d 20 18 sll %l4, 0x18, %l4
for (n=maxwidth ; n > count; n-- )
400069e8: 80 a6 80 1d cmp %i2, %i5
400069ec: 1a 80 00 08 bcc 40006a0c <vprintk+0x1a4>
400069f0: a9 3d 20 18 sra %l4, 0x18, %l4
rtems_putc(lead);
400069f4: 40 00 16 10 call 4000c234 <rtems_putc>
400069f8: 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-- )
400069fc: ba 07 7f ff add %i5, -1, %i5
40006a00: 80 a6 80 1d cmp %i2, %i5
40006a04: 0a bf ff fc bcs 400069f4 <vprintk+0x18c>
40006a08: 01 00 00 00 nop
rtems_putc(lead);
for (n = 0; n < count; n++) {
40006a0c: 80 a6 a0 00 cmp %i2, 0
40006a10: 22 80 00 0d be,a 40006a44 <vprintk+0x1dc> <== NEVER TAKEN
40006a14: d0 0e 20 01 ldub [ %i0 + 1 ], %o0 <== NOT EXECUTED
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
40006a18: ba 06 bf ff add %i2, -1, %i5
40006a1c: b8 14 a3 e8 or %l2, 0x3e8, %i4
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
40006a20: 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)])]);
40006a24: c2 4f 40 00 ldsb [ %i5 ], %g1
40006a28: ba 07 7f ff add %i5, -1, %i5
40006a2c: 40 00 16 02 call 4000c234 <rtems_putc>
40006a30: 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++) {
40006a34: 80 a7 40 11 cmp %i5, %l1
40006a38: 32 bf ff fc bne,a 40006a28 <vprintk+0x1c0>
40006a3c: c2 4f 40 00 ldsb [ %i5 ], %g1
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40006a40: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40006a44: 91 2a 20 18 sll %o0, 0x18, %o0
40006a48: 80 a2 20 00 cmp %o0, 0
40006a4c: 12 bf ff 90 bne 4000688c <vprintk+0x24> <== ALWAYS TAKEN
40006a50: b0 06 20 01 inc %i0
40006a54: 81 c7 e0 08 ret <== NOT EXECUTED
40006a58: 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' ) {
40006a5c: 22 80 00 7e be,a 40006c54 <vprintk+0x3ec>
40006a60: 82 10 20 00 clr %g1
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
40006a64: 80 a0 60 58 cmp %g1, 0x58
40006a68: 02 80 00 7d be 40006c5c <vprintk+0x3f4>
40006a6c: 82 10 20 00 clr %g1
base = 16; sign = false;
} else if ( c == 'p' ) {
40006a70: 80 a2 20 70 cmp %o0, 0x70
40006a74: 02 bf ff bf be 40006970 <vprintk+0x108>
40006a78: aa 10 20 10 mov 0x10, %l5
base = 16; sign = false; lflag = true;
} else {
rtems_putc(c);
40006a7c: 40 00 15 ee call 4000c234 <rtems_putc>
40006a80: 01 00 00 00 nop
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40006a84: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40006a88: 91 2a 20 18 sll %o0, 0x18, %o0
40006a8c: 80 a2 20 00 cmp %o0, 0
40006a90: 12 bf ff 7f bne 4000688c <vprintk+0x24>
40006a94: b0 06 20 01 inc %i0
40006a98: 30 80 00 6d b,a 40006c4c <vprintk+0x3e4>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
40006a9c: 82 10 20 00 clr %g1
40006aa0: aa 10 20 08 mov 8, %l5
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
40006aa4: 80 a6 a0 00 cmp %i2, 0
40006aa8: 16 bf ff b6 bge 40006980 <vprintk+0x118> <== ALWAYS TAKEN
40006aac: b2 06 60 04 add %i1, 4, %i1
40006ab0: 80 88 60 ff btst 0xff, %g1
40006ab4: 02 bf ff b4 be 40006984 <vprintk+0x11c>
40006ab8: 90 10 00 1a mov %i2, %o0
rtems_putc('-');
40006abc: 40 00 15 de call 4000c234 <rtems_putc>
40006ac0: 90 10 20 2d mov 0x2d, %o0
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
40006ac4: 80 a0 00 1d cmp %g0, %i5
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
rtems_putc('-');
unsigned_num = (unsigned long) -num;
40006ac8: b4 20 00 1a neg %i2
if (maxwidth) maxwidth--;
40006acc: ba 67 60 00 subx %i5, 0, %i5
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
40006ad0: 90 10 00 1a mov %i2, %o0
40006ad4: 40 00 47 68 call 40018874 <.udiv>
40006ad8: 92 10 00 15 mov %l5, %o1
40006adc: b8 92 20 00 orcc %o0, 0, %i4
40006ae0: 32 bf ff af bne,a 4000699c <vprintk+0x134> <== ALWAYS TAKEN
40006ae4: ac 10 00 15 mov %l5, %l6
40006ae8: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
40006aec: b6 10 20 00 clr %i3
while ((n = unsigned_num / base) > 0) {
40006af0: 10 bf ff bb b 400069dc <vprintk+0x174>
40006af4: b4 10 20 01 mov 1, %i2
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
40006af8: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
40006afc: 85 28 60 18 sll %g1, 0x18, %g2
}
if ( c == 'c' ) {
40006b00: 91 38 a0 18 sra %g2, 0x18, %o0
40006b04: 80 a2 20 63 cmp %o0, 0x63
40006b08: 12 bf ff 8a bne 40006930 <vprintk+0xc8> <== ALWAYS TAKEN
40006b0c: 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);
40006b10: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED
40006b14: b2 06 60 04 add %i1, 4, %i1
rtems_putc(chr);
40006b18: 91 2a 20 18 sll %o0, 0x18, %o0
40006b1c: 40 00 15 c6 call 4000c234 <rtems_putc>
40006b20: 91 3a 20 18 sra %o0, 0x18, %o0
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40006b24: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40006b28: 91 2a 20 18 sll %o0, 0x18, %o0
40006b2c: 80 a2 20 00 cmp %o0, 0
40006b30: 12 bf ff 57 bne 4000688c <vprintk+0x24>
40006b34: b0 06 20 01 inc %i0
40006b38: 30 80 00 45 b,a 40006c4c <vprintk+0x3e4>
40006b3c: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
40006b40: 88 10 20 01 mov 1, %g4
fmt++;
40006b44: b0 06 20 01 inc %i0
40006b48: 10 bf ff 61 b 400068cc <vprintk+0x64>
40006b4c: 85 28 60 18 sll %g1, 0x18, %g2
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
40006b50: a8 10 20 30 mov 0x30, %l4
fmt++;
40006b54: b0 06 20 02 add %i0, 2, %i0
40006b58: 10 bf ff 59 b 400068bc <vprintk+0x54>
40006b5c: 85 28 60 18 sll %g1, 0x18, %g2
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
40006b60: f6 06 40 00 ld [ %i1 ], %i3
if ( str == NULL ) {
40006b64: 80 a6 e0 00 cmp %i3, 0
40006b68: 02 80 00 3f be 40006c64 <vprintk+0x3fc>
40006b6c: b2 06 60 04 add %i1, 4, %i1
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
40006b70: c2 4e c0 00 ldsb [ %i3 ], %g1
40006b74: 80 a0 60 00 cmp %g1, 0
40006b78: 02 80 00 07 be 40006b94 <vprintk+0x32c>
40006b7c: b8 10 20 00 clr %i4
40006b80: b8 07 20 01 inc %i4
40006b84: c2 4e c0 1c ldsb [ %i3 + %i4 ], %g1
40006b88: 80 a0 60 00 cmp %g1, 0
40006b8c: 32 bf ff fe bne,a 40006b84 <vprintk+0x31c>
40006b90: b8 07 20 01 inc %i4
;
/* leading spaces */
if ( !minus )
40006b94: a8 89 20 ff andcc %g4, 0xff, %l4
40006b98: 12 80 00 0c bne 40006bc8 <vprintk+0x360>
40006b9c: 80 a7 60 00 cmp %i5, 0
for ( i=len ; i<width ; i++ )
40006ba0: 80 a7 40 1c cmp %i5, %i4
40006ba4: 08 80 00 09 bleu 40006bc8 <vprintk+0x360>
40006ba8: 80 a7 60 00 cmp %i5, 0
40006bac: b4 10 00 1c mov %i4, %i2
rtems_putc(' ');
40006bb0: 40 00 15 a1 call 4000c234 <rtems_putc>
40006bb4: 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++ )
40006bb8: b4 06 a0 01 inc %i2
40006bbc: 80 a6 80 1d cmp %i2, %i5
40006bc0: 0a bf ff fc bcs 40006bb0 <vprintk+0x348>
40006bc4: 80 a7 60 00 cmp %i5, 0
rtems_putc(' ');
/* no width option */
if (width == 0) {
40006bc8: 32 80 00 07 bne,a 40006be4 <vprintk+0x37c>
40006bcc: d0 4e c0 00 ldsb [ %i3 ], %o0
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
40006bd0: 80 a7 20 00 cmp %i4, 0
40006bd4: 22 bf ff 9c be,a 40006a44 <vprintk+0x1dc>
40006bd8: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40006bdc: ba 10 00 1c mov %i4, %i5
40006be0: d0 4e c0 00 ldsb [ %i3 ], %o0
40006be4: 80 a2 20 00 cmp %o0, 0
40006be8: 02 80 00 08 be 40006c08 <vprintk+0x3a0> <== NEVER TAKEN
40006bec: b6 06 e0 01 inc %i3
rtems_putc(*str);
40006bf0: 40 00 15 91 call 4000c234 <rtems_putc>
40006bf4: 01 00 00 00 nop
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
40006bf8: d0 4e c0 00 ldsb [ %i3 ], %o0
40006bfc: 80 a2 20 00 cmp %o0, 0
40006c00: 12 bf ff fc bne 40006bf0 <vprintk+0x388>
40006c04: b6 06 e0 01 inc %i3
rtems_putc(*str);
/* trailing spaces */
if ( minus )
40006c08: 80 a5 20 00 cmp %l4, 0
40006c0c: 22 bf ff 8e be,a 40006a44 <vprintk+0x1dc>
40006c10: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
for ( i=len ; i<width ; i++ )
40006c14: 80 a7 40 1c cmp %i5, %i4
40006c18: 28 bf ff 8b bleu,a 40006a44 <vprintk+0x1dc>
40006c1c: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
rtems_putc(' ');
40006c20: 40 00 15 85 call 4000c234 <rtems_putc>
40006c24: 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++ )
40006c28: b8 07 20 01 inc %i4
40006c2c: 80 a7 00 1d cmp %i4, %i5
40006c30: 0a bf ff fc bcs 40006c20 <vprintk+0x3b8>
40006c34: 01 00 00 00 nop
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40006c38: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40006c3c: 91 2a 20 18 sll %o0, 0x18, %o0
40006c40: 80 a2 20 00 cmp %o0, 0
40006c44: 12 bf ff 12 bne 4000688c <vprintk+0x24> <== ALWAYS TAKEN
40006c48: b0 06 20 01 inc %i0
40006c4c: 81 c7 e0 08 ret
40006c50: 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;
40006c54: 10 bf ff 47 b 40006970 <vprintk+0x108>
40006c58: 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;
40006c5c: 10 bf ff 45 b 40006970 <vprintk+0x108>
40006c60: aa 10 20 10 mov 0x10, %l5
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
40006c64: 10 bf ff c3 b 40006b70 <vprintk+0x308>
40006c68: b6 14 e3 f0 or %l3, 0x3f0, %i3
4001b918 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
4001b918: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001b91c: 03 10 00 78 sethi %hi(0x4001e000), %g1
4001b920: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1 ! 4001e3a4 <rtems_libio_number_iops>
4001b924: 80 a6 00 01 cmp %i0, %g1
4001b928: 1a 80 00 18 bcc 4001b988 <write+0x70>
4001b92c: 03 10 00 7b sethi %hi(0x4001ec00), %g1
iop = rtems_libio_iop( fd );
4001b930: d0 00 61 30 ld [ %g1 + 0x130 ], %o0 ! 4001ed30 <rtems_libio_iops>
4001b934: 83 2e 20 03 sll %i0, 3, %g1
4001b938: b1 2e 20 06 sll %i0, 6, %i0
4001b93c: b0 26 00 01 sub %i0, %g1, %i0
4001b940: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001b944: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001b948: 80 88 61 00 btst 0x100, %g1
4001b94c: 02 80 00 0f be 4001b988 <write+0x70>
4001b950: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001b954: 02 80 00 13 be 4001b9a0 <write+0x88> <== NEVER TAKEN
4001b958: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
4001b95c: 02 80 00 0f be 4001b998 <write+0x80>
4001b960: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001b964: 80 88 60 04 btst 4, %g1
4001b968: 02 80 00 08 be 4001b988 <write+0x70>
4001b96c: 92 10 00 19 mov %i1, %o1
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
4001b970: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001b974: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4001b978: 9f c0 40 00 call %g1
4001b97c: 94 10 00 1a mov %i2, %o2
}
4001b980: 81 c7 e0 08 ret
4001b984: 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 );
4001b988: 7f ff cf 6e call 4000f740 <__errno>
4001b98c: b0 10 3f ff mov -1, %i0
4001b990: 82 10 20 09 mov 9, %g1
4001b994: c2 22 00 00 st %g1, [ %o0 ]
4001b998: 81 c7 e0 08 ret
4001b99c: 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 );
4001b9a0: 7f ff cf 68 call 4000f740 <__errno> <== NOT EXECUTED
4001b9a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b9a8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001b9ac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b9b0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b9b4: 81 e8 00 00 restore <== NOT EXECUTED
40007854 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40007854: 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 );
40007858: 03 10 00 5d sethi %hi(0x40017400), %g1
4000785c: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 400177d4 <rtems_libio_number_iops>
40007860: 80 a6 00 01 cmp %i0, %g1
40007864: 1a 80 00 4d bcc 40007998 <writev+0x144>
40007868: 03 10 00 60 sethi %hi(0x40018000), %g1
iop = rtems_libio_iop( fd );
4000786c: f6 00 61 2c ld [ %g1 + 0x12c ], %i3 ! 4001812c <rtems_libio_iops>
40007870: 83 2e 20 03 sll %i0, 3, %g1
40007874: b1 2e 20 06 sll %i0, 6, %i0
40007878: b0 26 00 01 sub %i0, %g1, %i0
4000787c: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
40007880: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
40007884: 80 88 61 00 btst 0x100, %g1
40007888: 02 80 00 44 be 40007998 <writev+0x144>
4000788c: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40007890: 02 80 00 42 be 40007998 <writev+0x144> <== NEVER TAKEN
40007894: 80 a6 60 00 cmp %i1, 0
/*
* Argument validation on IO vector
*/
if ( !iov )
40007898: 02 80 00 3a be 40007980 <writev+0x12c>
4000789c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
400078a0: 04 80 00 38 ble 40007980 <writev+0x12c>
400078a4: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
400078a8: 14 80 00 36 bg 40007980 <writev+0x12c> <== NEVER TAKEN
400078ac: b5 2e a0 03 sll %i2, 3, %i2
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
400078b0: 82 10 20 00 clr %g1
400078b4: ba 10 20 01 mov 1, %i5
400078b8: 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 )
400078bc: c6 06 40 01 ld [ %i1 + %g1 ], %g3
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
400078c0: 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 )
400078c4: 80 a0 e0 00 cmp %g3, 0
400078c8: 02 80 00 2e be 40007980 <writev+0x12c>
400078cc: 88 10 20 01 mov 1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
400078d0: c6 07 20 04 ld [ %i4 + 4 ], %g3
400078d4: 82 00 60 08 add %g1, 8, %g1
all_zeros = false;
400078d8: 80 a0 00 03 cmp %g0, %g3
400078dc: b8 40 3f ff addx %g0, -1, %i4
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
400078e0: 86 80 c0 02 addcc %g3, %g2, %g3
400078e4: 0c 80 00 27 bneg 40007980 <writev+0x12c>
400078e8: ba 0f 40 1c and %i5, %i4, %i5
400078ec: 80 a0 80 03 cmp %g2, %g3
400078f0: 24 80 00 02 ble,a 400078f8 <writev+0xa4>
400078f4: 88 10 20 00 clr %g4
400078f8: 80 89 20 ff btst 0xff, %g4
400078fc: 12 80 00 21 bne 40007980 <writev+0x12c>
40007900: 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++ ) {
40007904: 12 bf ff ee bne 400078bc <writev+0x68>
40007908: 84 10 00 03 mov %g3, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
4000790c: 80 8f 60 ff btst 0xff, %i5
40007910: 12 80 00 1a bne 40007978 <writev+0x124>
40007914: b0 10 20 00 clr %i0
40007918: 10 80 00 05 b 4000792c <writev+0xd8>
4000791c: ba 10 20 00 clr %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40007920: 80 a7 40 1a cmp %i5, %i2
40007924: 02 80 00 21 be 400079a8 <writev+0x154>
40007928: 01 00 00 00 nop
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
4000792c: 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 )
40007930: d4 07 20 04 ld [ %i4 + 4 ], %o2
40007934: 80 a2 a0 00 cmp %o2, 0
40007938: 22 bf ff fa be,a 40007920 <writev+0xcc> <== NEVER TAKEN
4000793c: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
40007940: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
40007944: d2 06 40 1d ld [ %i1 + %i5 ], %o1
40007948: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000794c: 9f c0 40 00 call %g1
40007950: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
40007954: 80 a2 20 00 cmp %o0, 0
40007958: 06 80 00 16 bl 400079b0 <writev+0x15c> <== NEVER TAKEN
4000795c: 01 00 00 00 nop
return -1;
if ( bytes > 0 ) {
40007960: 32 80 00 02 bne,a 40007968 <writev+0x114> <== ALWAYS TAKEN
40007964: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40007968: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000796c: 80 a2 00 01 cmp %o0, %g1
40007970: 02 bf ff ec be 40007920 <writev+0xcc> <== ALWAYS TAKEN
40007974: ba 07 60 08 add %i5, 8, %i5
break;
}
return total;
}
40007978: 81 c7 e0 08 ret
4000797c: 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 );
40007980: 40 00 21 c1 call 40010084 <__errno>
40007984: b0 10 3f ff mov -1, %i0
40007988: 82 10 20 16 mov 0x16, %g1
4000798c: c2 22 00 00 st %g1, [ %o0 ]
40007990: 81 c7 e0 08 ret
40007994: 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 );
40007998: 40 00 21 bb call 40010084 <__errno>
4000799c: b0 10 3f ff mov -1, %i0
400079a0: 82 10 20 09 mov 9, %g1
400079a4: c2 22 00 00 st %g1, [ %o0 ]
400079a8: 81 c7 e0 08 ret
400079ac: 81 e8 00 00 restore
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
400079b0: 81 c7 e0 08 ret <== NOT EXECUTED
400079b4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED